Download / Listen:

Herding Code 169: Tom Dale and Rob Conery on the Ember.js / AngularJS Cage Match at NDC

Show Notes:

• Intro
• (00:18) K Scott and Rob asks Tom and Rob to introduce themselves and recap the Cage Match.
• (01:22) Tom describes the challenge and thanks Peter Cooper for moderating. Rob describes the scenario – start with installation and creating a new project, then move to routing and navigation between views.
• Demo vs. Reality
• (02:28) Rob says it’s fun to do a demo with Angular, but once you need to do more structured things you have to start over and reimplement with modules, etc.
• (02:43) Tom says that seeing the TekPub screencast about AngularJS informed a lot of their design for Ember.js. The result is a framework that gives you the same simplicity in getting started, but also grows with your application pretty easily.
• You Just Don’t Do That
• (03:22) K Scott asks if they pretty much match up if you’re looking at a feature checklist, and if it’s more about how you implement things. Rob says AngularJS is much more component based and talks about some things that came up during the cage match which were tricky in Angular, because "you just don’t do that".
• (04:18) Jon asks if there’s an overall effect to how you build your application because it’s just not how the framework works. Tom says it’s unacceptable when your designer comes to you with a user interaction design for you to tell them it’s just too hard to do in your framework, so you won’t do it. As framework developers, they spend a lot of effort on composability. Rob says that he sees Ember.js as more prescriptive, while AngularJS provides more building blocks. Rob says it seems like Rails to him, in that it just goes a lot better for you if you give in and go with the framework’s opinions.
• (06:13) Jon asks about how customization works in Ember.js, compared with Angular’s use of directives and filters. Tom says that’s done via helpers, referencing an example from the cage match.
• Client-side MVC implementation and The Importance of URLs
• (06:34) Rob asks Tom if it makes sense to say that "if you can think of it in a server-side framework like ASP.NET MVC or Rails, you can think of it in Ember.js". Tom says it’s not the same, because server-side MVC requests are short-lived compared to client-side applications. The real challenge is how you manage that state over time.
• (07:17) Tom says that they think URLs are really important. Their challenge has been how to marry the concepts of desktop MVC with the fact that they have a URL, and he thinks they’ve nailed it. Jon asks how that compares to Angular; Rob says that it’s not a primary concern in AngularJS or Backbone.
• (08:37) Tom says he considers your web application broken if he hits refresh and doesn’t see the same thing he saw before. Everyone screws this up, not because they’re idiots but because it’s hard, and if you don’t have this built into the framework you’re using you’ll mess it up. (09:06) K Scott asks what kinds of applications are the sweet spot for Ember.js. Tom says his first real professional programming gig was working on MobileMe / iCloud apps. They were big apps written in SproutCore. He says it’s important to be able to add features without breaking old features. Functional reactive programming and strong conventions help support this.
• State and Scope
• (10:38) Jon asks about the difference in maintaining state between Ember.js and AngularJS. Tom talks about how the Ember.js controller is similar to Cocoa and explains how the the controller presents the model to the template. Rob describes the $scope in AngularJS and compares the way AngularJS handles things more explicitly, whereas Ember.js is more conventional.
• (12:19) Tom says that he thinks the way AngularJS leverages JavaScript’s prototypal inheritance is really elegant, but it breaks down when you have very deeply nested UI’s pushing you into directives and more complex decisions. Rob says that you can share scope between AngularJS controllers, but the isolated scope situation is one of the things you struggle with in Angular.
• Testing, testing
• (13:54) Jon asks Tom about his comment on testability. Tom says that Angular’s Karma test support is really nice, and they’re working on catching up in Ember. Rob says that in AngularJS you’re just working with basic objects, which is really nice when you’re testing.
• (16:08) Tom says Ember.js requires you to do things correctly from the beginning; they won’t give you any foot guns to make things easier. Helpers help.
• (16:42) K Scott asks how change detection works. Tom explains the differences – AngularJS uses dirty checking against the DOM, while Ember.js uses accessors (like Backbone). Tom says that the performance is better in Ember.js. Angular’s situation will improve when they get object.observe, which ironically will happen at the same time Ember’s situation improves due to support for object proxies.
• (18:37) K Scott says he’d like to be able to conventionally wire up events. Tom talks about event delegation in Ember.js.
• The SEO Elephant in the Room
• (19:53) Tom says the biggest issue with JavaScript client-side applications today is SEO and describes why he’s not happy with the SEO solutions the other frameworks provide. They’re working on a solution that uses leverages the fact that they use Handlebars for templating to run a server-side process to generate SEO friendly content without any PhantomJS dependency.
• Using Ember.js When You’re Not Tom
• (22:28) Jon says that one issue with highly conventional frameworks is that it can be hard when you’re getting started and don’t know the conventions. Tom agrees and says that you’ll be frustrated if you experience learning difficulty before you feel the power and says the solution is documentation and good tooling. He mentions a coming Chrome extension that will show you what controller and model are backing content on the screen when you hover over it. K Scott says he’s pretty impressed with the Ember.js documentation.
• What’s Next? How about some Prollyfills?
• (24:45) K Scott asks about what’s coming out next. Tom talks about Polymer and Web Components. Jon asks if this was related to something he saw on Twitter the other day and Tom says it’s #extendthewebforward. The idea is that browsers should express primitives so browser vendors can innovate at the JavaScript level – rather than building speculative features into the browser, shipping a JS library that works cross-browser and can function as a polyfill (or "prolly"fill) if the feature doesn’t ship.
• So who won? Any missed opportunites?
• (29:45) K Scott asks who won the cage match and Rob admits to having been destroyed. K Scott asks why Rob keeps challenging framework authors to cage matches.
• (30:52) Jon asks Tom about the curveball that he threw at Rob during the cage match. Rob and Tom agree that coding a directive on the fly is not easy.
• (31:42) Jon asks Tom if there’s something that Rob could have asked Tom that would be hard in Ember. Tom says that they just added a competitor to filters using bound helpers, but if Rob had thrown list sorting at him he’d have had a hard time.
• (32:54) Jon asks about a viewer question on the emphasis on getting started vs. maintainability. Rob says that they’d first focused on composability, but nobody wanted to use it until it was easy to get started. Framework libraries don’t get the luxury of forcing a difficult learning experience on developers – if he can’t show value in 5 – 10 minutes, you’ll leave.
• Wrap?
• (34:42) K Scott asks Rob and Tom what else they’ve got going on. Rob plugs some TekPub videos (listed below) and Tom plugs some upcoming classes he and Yehuda will be offering (also listed below).

Show Links:

• Tom Dale (@tomdale, http://tomdale.net/)
• Rob Conery (@robconery, http://wekeroad.com)
• Norwegian Developers Conference (NDC)
• Ember.js
• AngularJS
• Ember101.com
• SproutCore
• Karma test runner for JavaScript
• Yehuda Katz – Extend the Web Forward
• Polymer
• Extensible Web Community Group
• TekPub: Get Involved! with Scott Hanselman
• Upcoming Ember.js courses from Tilde

Download / Listen:

Herding Code 168: John Sheehan on Runscope

Show Notes:

• Intro
  • (00:30) "What is Runscope and why should I care?"
  • (00:55) Runscope is the ultimate API integrator developer’s toolbox. It helps you solve the problems you encounter in dealing with API’s from a consumption standpoint. It takes invisible API traffic and makes it visible, then helping you do all sorts of things with it: debugging, sharing, retry a request from the website, testing features like response playback without hitting the API, webhook debugging, etc. When you rely on an API, you’re not just taking on a service dependency – it’s code code that’s running on someone else’s service, and you should treat it like it’s code that’s under your control. You should apply the same testing rigor and should have the same debugging facilities.
  • (03:25) Jon asks about the launch. Anyone can try it out now at runscope.com. John talks about the internal preview (shoutout to Kevin Dente, the first beta tester) and the launch at GlueCon and press at TechCrunch and TheNextWeb.
• (04:35) Overview of features:
  • Traffic Inspector
    • (04:55) In your code, instead of calling an API directly, you create a Runscope URL by including a Runscope bucket key and replacing dots with dashes. Essentially you’re pointing your API calls at Runscope, which then extracts the hostname and makes the API request for you. A lot of other tools require you to change your API calls by modifying your authentication, adding parameters, etc. Runscope doesn’t require any changes outside of the hostname, and all of your original headers and request parameters stay intact. This means you can just flip it on by changing your hostname and turn it off when done. You can then view all your requests in the Runscope website, filter to only show errors, All your requests show up in
    • (07:45) Scott says this is essentially a reverse proxy. John agrees that’s technically correct, but they avoid the term because they’re doing a lot more.
    • (08:13) Scott asks if Runscope adds headers to allow filtering or other things. John says the only modification they make is to add a Runscope message id header to allow lookup. They’re thinking of some things in the future like caching credentials to apply to a lot of requests and other features that benefit performance, security, etc.
    • (09:27) Jon asks about the security concerns, as Runscope is kind of like a man in the middle. John says they’re very concerned with security, and points to https://www.runscope.com/docs/security for a lot more information about their security practices. They’re looking at future things like encrypted storage, and currently if you make an SSL request to Runscope they will forward it over SSL to the API provider.
    • (11:45) Jon asks about cases like multi-legged auth. John says everything just flows through Runscope, with one exception – if a response comes back with a location header then Runscope will modify the location to a Runscope url so if the client follows it it’ll be captured.
    • (12:40) Scott asks about how geolocation works, since Runscope is making the request from a different location. John says that currently they’re making requests from US East Coast, but in the future they want to allow requests from specific geographic areas.
    • (14:10) Scott asks about a current app he’s working on which requires a custom certificate to connect to an API and asks if that would be supported. John says that they’re looking at both support for custom certificates as well as on -premises installations to support those scenarios.
    • (15:35) Scott asks about support for non-standard ports. John says they support that using a Runscope request port header.
  • Request Editor
    • (16:09) Jon asks about the Request Editor. John explains that they really wanted to make it possible to edit and create requests as easily as any other code. Their original inspiration was the hurl.it site. Jon interjects that he loves using hurl.it to see where shortened or dodgy urls will take him before clicking on them. John says they’ve taken the idea of hurl.it and really filled it out to include storage, advanced editing, etc. They also built in some helpers for basic auth, digest authentication, OAuth 1, OAuth 2 token generators, etc.
    • (19:45) Scott asks if they’ve looked at integrating OWASP tests to run some automated security inspection for things like SQL injection, XSS, redirect attacks, etc. John says he’d like to let people create collections and share them with others.
  • Shared Requests
    • (21:11) Jon says that when he was testing during the beta and hit a question, John just had him share the request with him. John says that he really wanted that feature when he was at Twilio, and they currently use it all the time internally.
    • (22:39) Jon asks if there’s a way to download or otherwise privately share a request. John says the best way to do that now is use team account, which allows for privately share requests within the team. They’re also looking at allowing redacting some fields in shared requests, so you can share a request without revealing your password or other sensitive information.
  • Passageway
    • (22:48) Passageway was based on the localtunnel project. It installs an agent on your local machine which forwards requests to a specific port to Runscope, and Runscope then creates a public URL. You can use Passageway to show off code running on your local machine, but you can also use it for debugging webhooks and testing API’s used in a mobile application (by pointing it at the public Runscope URL). Scott says he sees this as being useful in a continuous integration environment, and John says that a current customer is already doing this.
    • (27:33) Jon asks about the installation via pip, and John explains how pip relates to other package managers. They plan to provider other installers, and later the agent will do more than just Passageway – right now it also supports automatically creating Runscope urls for requests.
    • (29:27) Jon says that Passageway is the first place on the site where he sees something about paid accounts and asks John how they’re going to get rich. John says there are three reasons (access to passageway, team sharing and volume) to upgrade from a free account to a starter or team account. Jon asks about the naming of the starter account, and John says that naming and pricing are really hard. Scott offers some advice on enterprise friendly pricing.
• Starting a business
  • (32:47) Jon asks about the experience of moving from being a developer to founding a company. John says he’s started several small companies, and writing software has always been a way to solve problems for businesses. He tells his recent job history at Twilio and IFFT and how he and his co-founder Frank got really fed up with the lack of good API developer tools and how they got started, funded, and launched. Getting funded was both a finish line and a starting line.
  • (41:33) Scott and Jon talk about positive response they saw to the GlueCon launch: John spent the majority of the time describing the problem, then unveiled the solution. Scott compares John to Steve Jobs.
• What’s next
  • (43:05) Jon asks what’s next. John says they’re first focusing on dev-time troubleshooting. Next they’ll be focused on production use, especially high volume use cases. Long term they’re thinking about mitigating problems – handling or proactively monitoring for problems.
• Python
  • (45:14) Jon asks about John’s experiences building Runscope in Python and how he compares it to .NET. John says he’s really come around to significant whitespace and standard
  • (46:59) Scott asks if John’s noticed that there are fewer ways to solve a problem, as opposed to C# or JavaScript. John says that’s true for the most part. He comments on how he likes the small libraries and ecosystem.
• Runscope vs. other network tools like Fiddler and Wireshark
  • (49:19) Scott asks why you’d use Runscope rather than use things like Fiddler, Wireshark, etc. John explains proxies and applications modify the way the application works and doesn’t work well on servers – it’s cloud-native. It’s also social – sharing is built in. Thirdly, it’s not a desktop application.
  • (52:30) John says he’d like to write a Fiddler plugin to make the two work well together. Scott says that there’s one advantage to desktop applications – it can interact directly with the network stack. John agrees that developers need tools that work at all layers of the stack. Scott recounts a harrowing tale in which Fiddler had to be installed on a server for an application to work.
  • (55:20) Jon says he was wondering about integrating with Glimpse but that would require an API – does Runscope have an API? John says one’s on the way soon.
• Lightning Round inspired by John’s Traffic and Weather podcast (with Steve Marx)
  • (57:00) Jon says he’s really been enjoying the Traffic and Weather podcast, and the John and Steve have convinced him that API’s really can be interesting.
  • (57:50) JSON API – what is it, and is it good?
  • (59:34) What are webhooks, and why have you been talking about them?
  • (1:01:52) Should we stop writing REST SDK clients?
  • (1:04:29) Where is API security going? Is it OAuth 2 from here on out?
  • (1:05:21) Eric Williams (@motowilliams) asks "Ping Pong or Foosball? #gooooooaaaaaallll"
  • (1:06:17) Where are you speaking next (answer: API Days and API World, both in San Francisco)
  • (1:07:32) Do you support the HTTP 418 teapot response?

Show Links:

• John Sheehan (@johnsheehan, http://john-sheehan.com/)
• Runscope
• TechCrunch: Runscope Lands $1.1M From True Ventures And Andreessen Horowitz For Tools That Address The Broken API Plague
• TheNextWeb: Runscope raises $1.1m to help developers that rely on 3rd-party APIs
• localtunnel
• hurl.it
• Traffic and Weather podcast
• JSON API
• Zapier (REST hooks discussion on Traffic and Weather ep 11)
• Hyper Text Coffee Pot Control Protocol and the HTTP 418 (I’m a teapot) response

Download / Listen:

Herding Code 167: Glenn Block on scriptcs

Show Notes:

• Intro
  • (00:10) K Scott asks Glenn if he’s still working with Node at Microsoft. Glenn says he’s moved from command-line tools for node and is focused on Azure Mobile Services, but he still owns the Node SDK and the Node story for Azure.
  • (01:56) K Scott scriptcs is another way to write C# code outside of the IDE as script files. It’s inspired by Glenn’s work with Node.js. It leverages Roslyn, NuGet, and some conventions to simplify scripting, such as automatically pulling in NuGet packages.
  • (03:58) K Scott comments on the ability to reference assemblies using the #r directive. Glenn says it’s even easier than that – you can use #r to reference GAC’d assemblies, but assemblies in the local bin folder are automatically referenced. K Scott asks about the hooks to support that, and Glenn explains how Roslyn supports a lot of scenarios; since it ships it as NuGet packages it can be used outside of Visual Studios. Roslyn allows for code to exist outside of a class.
  • (06:33) Jon talks about his initial experiences, and how the REPL made it really easy to get started. Glenn explains how that works and explains how, using Chocolatey you can quickly install scriptcs and a NuGet package like MongoDb and then just start writing code in the REPL.
• Dependence on Roslyn
  • (09:35) Kevin points out that Roslyn is still in CTP and asks how that impacts scriptcs. Glenn says that since it’s a CTP Roslyn you can’t ship the binaries, but that’s not a problem for scriptcs since it pulls in the public NuGet packages. Roslyn is still evolving, it doesn’t yet support async / await or dynamic, for instance.
  • (11:13) scriptcs no longer takes a dependency on Roslyn. It uses a pluggable script executor which can use Roslyn but can potentially also use other script engines.
• Example uses of scriptcs
  • (12:33) K Scott asks for some common use cases. Glenn says that it’s possible to build apps because you can have one script that includes other scripts, then talks about the WPF calculator sample in the scriptcs-samples repo.
  • (14:18) Glenn says another use he’s seeing is automation – basically as a replacement for PowerShell. He talks about the Fluent Automation sample which uses script-cs to automate Selenium tests.
  • (15:18) Glenn talks about a real world example at a large trucking company who is using scriptcs to automate data processing jobs.
  • (16:05) Octopus Deploy has added support for scriptcs. He used a loader script that passes configuration to user-written scripts.
  • (17:42) Glenn says it’s useful to tinker and play with libraries or services and give an example of interacting with Azure Mobile Services in the REPL.
  • (18:38) One other example is extensibility – creating hooks and allowing end users to just drop in a scriptcs script to extend behavior.
  • (19:03) Kevin says that in the past people have used JavaScript engines to support extensibility. Glenn says that touches on a common question – why scriptcs as opposed to a lot of other options such as F#, Ruby, node, etc.? He gives two reasons: you get to stay in a language you’re familiar with, and there’s a "grow up" story to migrate from scriptcs to a Visual Studio project using the same libraries, same code, etc.
  • (20:03) Jon says that the PowerShell syntax is different enough that he can’t remember it. He talks about the idea of using scriptcs for installation and initialization scripts in NuGet rather than PowerShell. Glenn says there are kind of ways to use C# with PowerShell, but it’s not the same. He mentions a sample from @beefarino which lets you talk to scriptcs from PowerShell.
  • (23:01) Kevin asks what the migration process is to move from scriptcs to a C# project. Glenn says it depends on how much you take advantage of scriptcs features like Script Packs. Script Packs bring a node-like require module syntax into scriptcs. Glenn talks about the Web API script pack which adds in proper usings and gives you an API that’s very easy to use in script, without IntelliSense. They’ve talked about creating a project exporter which could set up a project and bring in your Script Packs, etc.
  • (26:25) Kevin asks if the Script Pack / Require experience could be brought into standard C#. Glenn says the general concept could work because it’s just a DLL, although there are some incompatible things like import statements. They’ve looked at writing Script Packs as script, which could make this more useful.
  • (28:40) Kevin talks about how the Node module system handles conflicting dependencies and asks if scriptcs handles that. Glenn says not yet, but .NET is now able to handle that so it could be added in. The general idea of script modules depending on other script modules makes sense, but conflicting dependencies might not be very useful. They’re thinking of NuGet packages with no assemblies, just does as content, and talks about some implications.
  • (31:32) Jon talks about how Glenn had told him that a lot of his bizarre feature requests wouldn’t fit in the core but could be useful as extensions, then asks about the extensibility points. Glenn runs through what you can do: change the engine, use Script Packs, bring in NuGet packages, possible later REPL extensions via global NuGet packages. He says they’re following the Node team’s principles of keeping a small tight core and pushing features towards extensions.
• Questions from Twitter
  • (34:14) Jeff Schumacher (@codereflection) asks Glenn to compare scriptcs performance vs. compiled code. Glenn says that there can be a short startup impact and potentiall
  • (35:58) Akim Boyko (@AkimBoyko) asks if it’s possible to run scriptcs without Roslyn, async/await support and in sandbox mode. Glenn talks about the Mono impact of running without requiring Roslyn support. Roslyn will be getting async/await support at some point, but it could also be added via CodeDom if people implement that. However, CodeDom doesn’t support the classless system that Roslyn does.
  • (38:04) Simon Cropp (@SimonCropp)  asks if scriptcs support plugging into the build pipeline? Eg if I wanted to plug in Fody (https://github.com/Fody/Fody/).
  • (39:41) Several questions on how scriptcs compares to Snippet Compiler, LinqPad and csscript.
  • (41:12) Dan Vanderboom (@danvanderboom) asks if scriptcs let us run a .cs code file by itself anywhere in the file system? Glenn says no and explains why he’s not sure that would be useful.
  • (42:55) Tomasz Janczuk (@tjanczuk) asks When will integration of scriptcs and edgejs be done? ;) Glenn talks about how the projects have both grown up together and how the two would be useful together.
• Debugging and IntelliSense
  • (45:29) Jon talks about how he messed something up in the samples and debugged it and asks about debugging support. Glenn points out that you can directly debug an EXE in Visual Studio and explains how to debug scriptcs code in Visual Studio. He also talks about MDbg which Glenn (and apparently everyone else) didn’t know existed. He also mentions a Script Pack for debugging.
  • (48:15) Jon says the REPL is great, and yet he’d sometimes like IntelliSense. Glenn talks about a lightweight WPF editor that’s in progress, but says if you get to a point where things are getting complex it’s probably time to move to move from scriptcs to a project. Jon says that for the most part Script Packs seem to really simplify the code to the point where you don’t really need IntelliSense, and Glenn agrees.
• Shoutouts
  • (50:45) Glenn calls out the two other coordinators on the project, Filip Wojcieszyn (@filip_woj) and Justin Rusbatch (@jrusbatch) as well as some other top contributors.
• Shell capabilities, TSR scenarios
  • (52:03) Kevin asks if there are possible changes to make it more shell-like with things like piping. Glenn says they currently have a poor story for arguments, but it’s coming. You can currently pipe text, but he’s not sure about piping objects.
  • (54:30) Jon says he’s got some AutoHotKey scripts and asks if scriptcs could handle that kind of thing.
• Future plans
  • (56:10) K Scott asks where things are going in the future. Glenn mentions scriptcs modules, aliases, a better Visual Studio experience, export project, and saving DLLs.
  • (1:04:25) Glenn talks about some interesting ideas on GitHub, like a command to break execution into the REPL. They’ve got 20 active contributors, so things are moving fast.
  • (59:54) Glenn says he’s got a personal interest in seeing some adoption in Microsoft – such as adding scriptcs scripting to other projects.
  • (1:00:25) Glenn talks about one question that comes up: should the Roslyn team have tackled the scriptcs scenario?
• Wrap up
  • (1:01:10) K Scott asks about Glenn’s upcoming plans, speaking engagements, etc.
  • (1:02:27) Jon makes a last minute sales pitch to try it out – you can install in seconds from Chocolatey and just start playing at the REPL. Glenn points one gotcha – scripts which run servers need to be run as admin.

Show Links:

• Glenn Block (@gblock, CodeBetter blog,  MSDN blog)
• scriptcs – Living on the edge in C# without a project on the wings of Roslyn and Nuget – Glenn’s post explaining scriptcs and why the project started
• Scripting ease with Script Packs 
• Roslyn CTP
• scriptcs samples repository 
• Fluent Automation sample
• ScriptCS or PowerShell post by @beefariono
• scriptcs on Dot Net Rocks
• Project-less scripted C# with ScriptCS and Roslyn (Scott Hanselman)

Download / Listen:

Herding Code 166: Tomasz Janczuk on Edge.js

Show Notes:

• Intro and background on Edge.js
• (00:40) Tomasz has been focusing on Node.js at Microsoft for the past 3 years. He’s been working on making Node.js run well on Windows. He’s also worked on hosting Node.js on Windows Azure with IISNode.
• (02:08) Jon asks about Edge.js’s original name, Owin. Tomasz explains how that made sense with the original scope – connect middleware and express handlers – but it’s grown since then so it needed a more generic name.
• (02:45) Edge.js lets you run Node.js and .NET code in one process and provides interop mechanisms between the two.
• (03:05) Jon asks why that’s useful. Tomasz says you can do pretty much anything in either Node.js or .NET, but some things work a lot better on one platform. He gives examples like using ADO.NET to connect to SQL Server and running CPU bound computations as multi-threaded .NET code from the single-threaded Node.js event loop. There are two classes of scenarios: things that work better on one platform, or writing native extensions to Node.js without having to drop all the way down to raw C and native OS mechanisms.
• (06:11) Jon brings up two questions from Twitter about Mono support (Jason Denizac @_jden "when’s mono support coming?" and Kevin Swiber "Mono support? Can we do legit Node modules in C#? Are grilled hotdogs really better than boiled?" Tomasz says not yet, but it’s high on the list. There are some complications to implement that support since Edge.js uses C++ CLI, which isn’t available on Mono.
• Getting started and samples
• (07:57) Jon asks what’s involved in setting it up. He says he ran npm install edge, then npm install edge-cs. Tomasz explains why he didn’t need to install edge-cs – C# support is built in, other language support plugs in.
• (08:43) Jon asks about the samples. Tomasz explains the different ways of integrating CLR code into Node.js and talks about how the samples show these approaches.
• (10:36) Jon says he liked how the samples progressed from very basic to pretty complex. Tomasz says you can do just about anything in Edge.js, but there’s a specific interface you need to follow in order to work smoothly between the Node.js async model and many synchronous operations in .NET. Every function in Edge.js uses an async function delegate, so you end up using small wrapper functions in some cases.
• Marshalling and interop
• (13:08) Kevin says this reminds him of COM / .NET interop and issues with object lifetime, garbage collection, etc. Tomasz says that that the async function delegate solves the threading models. Object lifetimes are controlled because everything is marshalled by value.
• (16:22) Kevin asks if the marshal by value prevents working directly with the CLR object. Tomasz says that you can handle this using function proxies to create closures over CLR states.
• (17:45) Scott K. asks if structs eliminate the serialiazation issues. Tomasz clarifies that the marshalling process is reflecting over the objects in .NET and recreating a synonymous JavaScript. Scott says this sounds like thunking from days of old.
• (19:27) Jon says that he saw one sample that allows for debugging inline .NET code in a JavaScript file. Tomasz explains that this is done using the codedom compiler to create an in-memory assembly with debugging information, which can be attached to from Visual Studio.
• (21:25) Jon says he thinks this sounds useful for using a NuGet package in a Node.js application and asks if there’s support for pulling in a NuGet package. Tomasz says that at this point it’s up to you how you’d get the assembly downloaded and set up, but that there’s an open issue to get script-cs integration going and that would handle this.
• Overhead and performance
• (23:06) Jon asks about the overhead of running two virtual machines and marshalling. Tomasz says there is some overhead, but it’s better than running two different processes. Edge.js is built for solving some specific scenarios, and it’s fast in those
• (24:55) Kevin asks if there’s a delay when Edge.js spins up. Tomasz says that happens when you require Edge, but it’s not really noticeable.
• Misc questions
• (25:55) Jon asks what was the hardest part of implementing Edge.js. Tomasz says the function proxies to handle lifetimes and reconciling threading models.
• (27:45) Scott says this sounds useful for authentication or using a legacy .NET library. Tomasz lists several more.
• (29:20) Kevin asks how exceptions are handled. Tomasz explains how the exceptions are marshalled and thrown across VM boundaries.
• (30:15) Kevin asks if it’s tied to specific Node.js versions. Tomasz says it works on all current stable versions.
• (31:30) Question from Twitter: @jeremydmiller "I’ve seen a lot of samples of hosting . Net in node, but how about running node in a .net process?" Tomasz talks about an open issue, Mission Double Edge which would handle that. He explains that the challenge is that Node.js doesn’t have a hosting model.
• (33:20) Jon says he saw several of the samples had the C# script named with .CSX extension and asks about that. Tomasz says that this is partly done to follow Roslyn conventions, including specifying assemblies as references in code using #r.
• Future plans and next steps for listeners
• (34:25) Jon asks what’s planned going forward. Tomasz talks about Mono support and adding support for additional languages, including F# (note: this has been added http://tjanczuk.github.io/edge/#/3) . Jon asks what’s involved in adding language support.
• (36:30) Jon asks about the relationship with OWIN. Tomasz says there’s a separate module which allows you to plug any OWIN compatible .NET application and plug it into an Express.js pipeline. Jon says this reminds him of the Edge name and Tomasz explains that the idea is that mathematically an edge connects two nodes, so Edge.js connects differe.
• (38:25) Jon asks about next steps for people to get started.
• (38:55) Jon asks if this is a Microsoft project. Tomasz says it’s his own separate open source project that’s inspired by his day job, and this allows him some more flexibility to work with the community. He lists some of the community contributions they’ve seen so far.

Show Links:

• Tomasz Janczuk (@tjanczuk, blog)
• Official Edge.js site: http://tjanczuk.github.io/edge/#/
• Edge.js on GitHub: https://github.com/tjanczuk/edge

Download / Listen:

Herding Code 165: Mark Seemann on AutoFixture and Unit Testing

Show Notes:

• AutoFixture
• (00:44) AutoFixture is an open source library that simplifies the "Arrange" part of the standard Arrange / Act / Assert steps in unit tests.
• (01:20) Jon asks about anonymous variables. Mark says he got that terminology from Gerard Meszaros’ book, xUnit Test Patterns. Anonymous methods and variables are necessary for a test, but their implementation doesn’t matter.
• (02:23) Mark describes the test data builder pattern, from the book Growing Object-Oriented Software. The pattern works well, but it gets to be repetitive and mechanical to write and maintain, so he wanted to automate it. AutoFixture uses reflection to create the needed instances.
• (04:00) Jon asks about the usage pattern for AutoFixture.(04:16) Jon asks about the different values returned for strings, ints, etc. Mark explains how that’s changed over time – numbers no longer just return sequential values, they now return random small numbers.
• (05:20) Mark explains equivalence classes. Jon says "Okay" a lot. You can use AutoFixture in cases where you don’t care about the value; in cases where you do, you can configure what you want to. Mark explains some of the different ways you can use the AutoFixture API to set specific values when needed.
• (09:15) Jon asks how AutoFixture works with mocking. Mark says there are NuGet packages which will interface with Moq, Rhino Mocks, FakeItEasy and NSubstitute.
• (10:25) Jon asks Mark what his talk said about equivalence. Mark explains identity and value objects with an example with overriding the equals operator on a money value object. The more you can model your domain as value objects, the easier your tests become. Jon asks if this is an example of TDD driving a good design. Mark says that he tried letting tests completely drive his design a few years ago, but he found that it alone didn’t drive a very good overall design.
• Testing philosophy, Testing Trivial Methods
• (15:56) Jon asks Mark about his recent post advocating testing trivial methods. Mark says that his post was in response to Robert C. Martin’s post, The Pragmatics of TDD. Mark makes a case for testing getters and setters – if you decide to use a property rather than a field, that decision probably warrants a test to verify the property is maintaining the behavior that drove the original decision.
• (20:38) Jon asks how this applies to the example of testing ASP.NET MVC controller code. Mark says he’s in the habit of testing everything, and has written a lot of tools to make writing the tests easy enough that it’s not a concern. The question is, how much does it cost you if a unit of code doesn’t function as designed? Mark explains how a controller action models the data flow in an MVC application, and decomposing the flow allows you to write smaller, simpler, more targeted tests.
• (25:03) Jon asks how this relates to outside-in testing using tools like Selenium. Mark says that testing at the external boundary is fine if you can, but most applications become complex enough that boundary testing would require an impractical number of test cases.
• Wrap up
• (26:04) Mark says that many of these concepts are covered in more detail in Mark’s Pluralsight course.

Show Links:

• Mark Seeman (@ploeh, blog)
• AutoFixture
• Book: xUnit Test Patterns: Refactoring Test Code
• Book: Growing Object-Oriented Software, Guided by Tests
• Blog post: Test trivial code
• Blog post by Uncle Bob Martin: The Pragmatics of TDD
• Pluralsight announcement: New course: Advanced Unit Testing

Download / Listen:

Herding Code 164: OWIN and Katana with Louis DeJardin

Show Notes:

• Intro
• (00:44) Scott and Louis explain what OWIN is.
• (01:33) Louis explains the difference between OWIN (the community standard) and Katana (actual bits – an implementation of the OWIN standard for ASP.NET).
• (03:18) Jon asks if this is similar to the distinction between HTTP / HTML standards and browser implementations. Louis explains what’s required for an implementer to participate in a request. Each request calls a simple func with an IDictionary<string> which returns a task.
• The killer app: middleware
• (04:54) Scott talks about how the pipeline might not sound like much, but it can support a lot of really useful middleware scenarios like static caching and domain splitting – especially in a way that’s common across frameworks.
• (06:05) Louis talks about the challenge they’ve had in describing the benefit of OWIN in non-academic terms, and that it’s not until you want to apply cross-framework concerns like authentication that OWIN really shines.
• (07:52) Scott says that previously these kinds of concerns – logging, etc. – were wrapped up in System.Web, and they had performance implications regardless of whether you used them. The pipeline model lets you avoid those hits unless you explicitly want the features.
• (10:03) Scott mentions some of the frameworks which have implemented OWIN, including NancyFx, Fubu, ServiceStack.
• (10:50) Kevin says that the current implementation examples are full web frameworks rather than middleware. Louis says that probably because ASP.NET and IIS already had pipeline implementations so there’s less of a forcing function than there was with Node and Ruby. Scott says that since the current implementations already have full stacks, there’s less need to plug in modular solutions. Jon says he thinks that the late arrival of NuGet and other open modular systems like this mean it’ll take a while to get traction.
• (14:40) Louis says we’ll need a killer app, and HttpListener hosting alone isn’t that. Jon asks if you’d host Katana under IIS to manage the process. Louis says yes, and until there are other hosts than IIS he doesn’t see the hosting as a big draw – he thinks auth is probably it.
• 1640 Scott says he could see auth frameworks and scaling middleware. Louis says that David Fowler updated JabbR to run on OWIN, and was able to move some of the scale pieces into OWIN middleware.
• (18:25) Jon asks if he can take an existing ASP.NET application to start taking advantage of middleware without rewriting the application. Louis says that if you add the Microsoft.Owin.Host.SystemWeb NuGet package, you can put an OWIN pipeline on the route table. You can also use an IHttpHandler to plug in middleware. They’re looking at third option – an integrated pipeline module which will delegate to the application if an OWIN handler doesn’t pick it up.
• (22:22) Jon asks Louis has some other ideas for middleware, and Louis lists several (static file handlers, authentication, etc.) and points to Rack and Node as examples. He lists another example – anti-bot  protection that returns an HTTP 200 for a URL pattern.
• (23:50) Jon asks if it’s possible to plug things in at runtime. Louis talks about the Startup class – it’s a POCO class so you can easily work with it via IoC, plug things in whenever – it’s just code.
• (25:05) Scott says he looked at implementing URL rewriting in middleware. Louis explains how this works perfectly with the pipeline and describes how you could also use this to monitor 404s.
• (26:45) Scott says hosters could implement middleware to set ETAGS, enforce things, etc.
• (27:40) Louis explains why it’s really powerful to have middleware that’s not coupled to a specific implementation like ASP.NET MVC.
• (28:35) Jon asks if it’s possible that some of this middleware could run on hardware. Louis says it is, and gives an example with a reverse proxy.
• (29:57) Scott talks about breaking middleware into application and networking uses and talks of some optimizations that could be done in middleware.
• Next
• (31:48) Scott asks where we go from here – are done? What’s the next goal? Louis says the current 1.0 version of Katana has IIS hosting; the 1.1 version will add production grade HttpListener and self host story, and after that it’s about supporting emerging standards and looking for synergies. Louis says documentation would be nice, but Scott says that the model is so simple that there’s not a lot to document.
• (34:50) Scott and Louis talk about how this will affect the ecosystem in general, with an example of how smoothly the SignalR implementation worked.
• (35:25) Jon asks about the future for hosters like Azure, AppHarbor, etc. Louis talks about an example for  supporting zip file based deployment, Mono hosting.
• Getting involved
• (37:05) Louis talks about what’s available in the Katana Project, including sample code and pre-release packages. The Google Group – net-http-abstractions – is the best place to discus OWIN.
• (38:15) Jon asks if the Katana project takes pull requests. Louis says it’s run under the MS Open Tech organization and is clear to take pull requests from developers who have signed a contributor license agreement. Jon asks for areas where they’d like help. Scott says he’d like to see lots of middleware; Louis he’d love to see an OWIN Contrib project emerge.
• Questions from Twitter
  • (41:05) Sean Massa (@endangeredmassa): Is it possible to use the DLR?
  • (41:45) Eric Hexter (@ehexter): what do MVC and Web Forms look like on OWIN. Louis says there are two exciting things there – you can have an Owin pipeline running in front of your application, or you can use self hosting to put an application inside of your own process (not supported but fun!).

Show Links:

• Louis DeJardin (@loudej, blog)
• OWIN – Open Web Interface for .NET
• Katana Project on CodePlex
• Google Group: .NET HTTP Abstractions
• NuGet package: Microsoft.Owin.Host.SystemWeb
• GitHub: ServiceStack.Owin
• NuGet: Nancy.Hosting.Owin
• NuGet: FubuMVC.Katana
• Herding Code 60: Spark View Engine with Louis DeJardin

Download / Listen:

Herding Code 163: Sticker Tales and Building Windows Store apps

Show Notes:

• Introductions
• (00:39) Damien describes what he’s been up to since we last talked to him.
• (01:25) Robert worked on the Windows user interface, then XBox.com, then several apps for NetFlix.
• (02:57) Jon asked about the experience of building high scale customer facing applications at XBox and NetFlix. Damian tells about how they ran the XBox store on two servers.
• Building Sticker Tales
• (03:38) Jon asks how they decided to build a sticker book app. Robert explains how they got started.
• (04:45) Robert describes how they decided to spend some money on professional illustration.
• (05:40) Jon describes how Sticker Tales works and how he loves watching what his five year old daughter comes up with, especially how she plays with scale. Robert says he sees the same as his daughter
• (6:57) Damien describes some of the surprises they saw in user testing.
• (8:30) Scott K asks if their experiences in watching how kids interact with touch gestures will influence their design in general.
• (9:18) Damien talks about some of the changes the kids inspired, especially using direction of motion to flip things. Jon says he wants this flip gesture everywhere, and Scott K says he thinks kids should be interaction testing all touch interfaces.
• (10:44) Damien gives another example with how pinch / zoom didn’t work well for kids, and they added a handle instead.
• (11:26) Jon asks about how they were interacting with the illustrators. Robert describes the interaction and how they handled different image sizes, exporting, etc.
• In-app purchases
• (13:37) Jon asks about the "free app + in app purchase" model. Robert explains why they chose that model.
• (14:48) Jon asks if the in-app purchases were difficult to set up. Damien says yes and explains how it was set up. Robert says the purchasing is easy, but the delivery is up to you as the developer.
• Google Analytics and the CSharpAnalytics library
• (17:00) K Scott asks about what kind of analytics they were using. Damien explains how they used Google Analytics and explains they published that library as CSharpAnalytics on GitHub. Damien likes tracking usage patterns, Robert says he loves the real-time and geographic views.
• (18:19) Robert says they track initiated vs. completed purchases, and they see it’s only about 10%. Jon speculates that’s because kids start the purchase and the parents veto it.
• (19:08) K Scott asks if it’s only available for Windows 8. Damien says that’s all that’s documented, but he’s set it up to work with Windows Phone as well.
• (19:30) Jon asks about how auto-analytics work.
• Platform targeting – iPad future, Windows 8 implementation
• (20:40) Kevin asks if they’re looking at porting this to iPad. Robert says they’re looking at using Xamarin for that.
• (21:24) Jon asks about what Windows 8 integration points they’re using. Robert discusses live tiles, sharing, search, and background download API support.
• (22:58) Jon asks if they used C# / XAML or HTML. Damien says they went with C# / XAML partly because the touch API support seemed better early on.
• SharpDX and performance
• (23:30) Damien explains that they’re using SharpDX to be able to take screenshots for live tiles, sharing, etc. Jon gets confused and thinks they’re using SharpDX everywhere, but Robert explains it’s only for saving screenshots – everything else is using image controls.
• (26:54) Jon asks if they ran into any performance issues. Robert explains some of the guidelines they’d learned at NetFlix and says that everything’s worked really well in StickerTales. Damien says they’ve seen great performance on Surface / ARM as well. Jon says he’s seen Audacity recompiled for ARM and it worked great on Surface, too.
• Data storage and MVVM perspective
• (28:34) Jon asks what they’re using for data storage; Damien says using XML.
• (28:46) Robert says they’re not using MVVM because it just doesn’t work with the Microsoft tools and isn’t worth it for the kinds of thin clients they’ve been building, even at NetFlix.
• Western Digital companion application
• (30:07) Jon asks how about their next project, a companion application for Western Digital. Damien describes how Western Digital wanted an application that would present an all-up aggregate view of media on external media.
• (30:42) Damien says they using SQLite for that project and explains the challenges they ran into with hierarchical data storage in a relational database engine.
• Unit Testing Windows Store application code
• (32:52) Kevin asks about the testing story. Damien says they used MSTest and it all worked fine, with the exception of determining code coverage. Jon asks some questions about testing frameworks and test focus for Windows Store applications.
• (35:20) Robert says the WinRT platform wasn’t written in a very testable manner – there are lots of static classes and a generally test resistant API.
• Business Challenges and Opportunity for Windows Store Developers
• (36:38) Jon asks about the challenges of building and running a company that’s building Windows 8 applications. Robert describes some of the perception and education issues they face in selling the potential to customers.
• (38:20) Scott K compares the current Windows Store opportunity to the pre-iOS Mac development market – a nice place to create a niche product and make a good living. Damien says it is nice to be featured in the store, and that’s difficult on other platforms. Robert says that ease of developing Windows Store applications means that you still need to market your applications.

Show Links:

• Damien Guard (@damienguard, blog)
• Robert Sweeney (LinkedIn)
• Sticker Tales
• Attack Pattern
• CSharpAnalytics
• SharpDX
• WD Companion App
• Herding Code 50: Damien Guard on LINQ to SQL, Entity Framework, and Fontography

Download / Listen:

Herding Code 162: Whacha doin, Goodbye Google Reader, scriptcs and Lightning Round!

Show Notes:

• What are you up to?
  • (00:29) Scott K is doing MVC with a lot of JavaScript.
    • He laments the quality of the code he’s working with.
    • There’s a discussion of how bad code happens and how to clean it up.
  • (07:58) Kevin’s been working on his GreaterThanParts site.
    • He soft launched it on twitter and got more response than he expected, but it’s been holding up.
    • It’s a full JavaScript stack – Node, Backbone, Mongo.
    • Kevin was surprised how resistant developers were to trying out the site via Google / Facebook login, so he set up an anonymous (cookie based) login.
    • Scott K has some specific feature requests.
    • Jon asks if the design feedback was coherent or contradictory. Kevin says some was really good, a lot wasn’t
  • (15:40) Jon talks about the ASP.NET Jump Start event he did in February and some upcoming Web Camp he’s doing – Denmark, Istanbul, Sunnyvale, San Diego. In his spare time he’s working on a book about programming Windows 8.
    • Scott K mentions a blog post he read about a developer who was frustrated he couldn’t store password protected zip files or preview office docs. Jon says it’s an app model and it’s different than building desktop apps. Kevin wonders about how the updates will work for Windows Store apps.
    • Scott K says he read about limitations in displaying help files. Jon says that some things are easier to do using the HTML dev model, and he’s seeing some people writing business logic in C# and using it in an HTML app.
    • K Scott talks about the current campaign to pay developers for apps. Jon says he thinks that may be driven by the fact that all the tech columnists just write about the number of apps in the store, but he agrees that fewer quality apps is better. The Windows Store has a try / buy model, which effectively halves the number of apps required compared to Android and iOS. Jon talks about how he’s been using the Surface RT.
  • (25:49) Google Reader
    • K Scott asks if anyone’s upset. Kevin is.
    • Scott K hasn’t used it in a while because he just uses Twitter and an RSS reader he likes.
    • Jon says he used to read tons of feed, but he now gets most of his info off Twitter, Hacker News, and TheCadmus.com
    • Scott K says he’s going to need to replace Reader because he follows some feeds he cares about that will never make their way onto Hacker News.
    • Jon says he used to use Reader more when it had Google Gears support. He talks about how he tried to write his own RSS reader which never materialized, but he learned a lot along the way.
    • Kevin says the bigger problem is that so many apps use Google Reader as an RSS sync backend.
    • Jon says he’s happy that the whole RSS system isn’t dependent on Google Reader, and that it’s a good thing that major parts of the web stayed open.
  • (34:45) scriptcs
    • K Scott overviews the idea.
    • Scott K says he thinks it’s interesting – a natural use of Roslyn. He’s been wanting something that would output assemblies so it could create projects.
    • Jon talks about some of the samples they’ve got, including WPF, Mono, etc. He says he’d prefer it to PowerShell since it could be more portable and the syntax is better.
    • Kevin says many of these ideas came from the Node community. He’s really enjoying the low overhead of working in vim. Scott agrees. Jon says he doesn’t see Visual Studio delays, maybe because he’s not using heavy add-ins. A border skirmish erupts. Kevin says that he thinks that .NET programming kind of requires Visual Studio. Jon like the new web tools stuff.
  • (44:27) Lightning Round!
    • K Scott asks if anyone cares about the S4 release. Nobody does. We’re all kind of tired of smartphone releases.
    • K Scott asks what we’d recommend for teaching someone to program. Scott K, Kevin, and Jon all agree that they’d start with the web and JavaScript and talk about some of their favorite tools.
    • K Scott asks what everyone thinks about the new Rearden.js library with the Rearden Metal templating system.

Show Links:

• Greater Than Parts – Kevin’s new "simple shopping for complex projects" site
• ASP.NET Jump Start
• Web Camps tour – Jon’s post announcing the Spring 2013 tour
• Blog post: Why are there no great Windows 8 apps? Because of WinRT. A developer’s view
• Google Gears
• Tree Surgeon
• Powering Down Google Reader
• TheCadmus
• scriptcs – Living on the edge in C# without a project on the wings of Roslyn and Nuget
• http://scriptcs.net/
• LiveReload
• Codecademy
• JS Bin
• repl.it
• ReardenJS
• Vapor.js

Download / Listen:

Herding Code 161: Single Page Applications with John Papa and Ward Bell

Show Notes:

• Intro
  • (01:10) K Scott asks John Papa about to overview what’s just been released.
  • (01:24) Jon explains how he remembers the ASP.NET and Web Tools 2012 release, comparing it to a video game "map pack".
  • (02:04) John says that one of the new features in this release is that you can create new File / New / Project templates for ASP.NET MVC using VSIX.
  • (03:18) Scott K says you can find all the new goodies at http://asp.net/vnext.
• Hot Towel overview
  • (03:37) K Scott asks what happens when you create a new Hot Towel project.
  • (04:30) K Scott asks what’s included:
    • Durandal
    • Knockout
    • Breeze
    • Some other nice things: jQuery, Bootstrap, Moment
    • The useful parts of the ASP.NET stack
• Durandal and getting the various libraries to play well together
  • (06:00) Jon asks if everything in the Hot Towel parts fit together well, and if it was hard to get them to play well together.
  • (07:14) Durandal uses Require.js for AMD for script dependency resolution. Hot Towel is still using ASP.NET Bundling and Minification system, although when you deploy you can use Durandal’s compilation system.
  • (09:03) Ward talks about what he likes about Durandal.
    • You can bring any thing you know from Caliburn.Micro in, including convention based view composition.
    • It includes a lot of useful debugging and tracing information in the console. That includes intercepting problems with Sammy.js (which would otherwise just report "Error" without any context), binding failures, etc.
  • (10:24) Hot Towel also includes Toaster, which is really useful for debugging.
  • (11:15) Hot Towel has really been carefully assembled and and configured so it all really works well together.
  • (12:06) John says Hot Towel solves a common problem people experience when getting started with SPA development – it’s hard to figure out which libraries to use and how to hook them together.
• What’s the sweet spot? Line of business apps? Websites?
  • (13:20) K Scott asks if the sweet spot for Hot Towel is for for line of business applications. John says that’s what it’s been used for. It’s great for data intensive applications, but he says it’s not a good fit if you’re just building a website.
  • (13:53) Jon asks about the SEO story. John says there really isn’t a great solution for it, but says that for most SPA stories – e.g. line of business CRUD apps – you probably don’t need or want search engines to be able to read it. For some cases, like a store scenario, you might want a hybrid solution. The store would be a standard website that’s SEO friendly, but when you shift to buying something you enter a SPA experience.
• Organize all the scripts!
  • (15:45) K Scott asks how John organizes code for a SPA. John says he likes to put all the application specific scripts into a separate /scripts/app folder. Jon says he noticed that in the RTM version of the SPA template, and Ward and John confess to having been the driving forces behind that change.
  • (17:37) John talks about the two crowds who are using these scripts – there are people who have been using JavaScript for a while, and developers who are used to C# and are starting to do more JavaScript development. Simple things like pascal casing vs. camel casing make a big difference in how experienced JavaScript developers perceive and enjoy the shipped JavaScript code.
• Bringing grownup architecture into client side coding
  • (18:19) Ward talks about other problems in earlier versions, like lumping the viewmodel and data access, etc. He says he understands the effort to make things easy for beginners to figure out, and Scott talks about some of the sloppy, oversimplified JavaScript in some other Microsoft releases. John says that the new script organization in the release turned out both better and easier to understand.
  • (20:48) Scott talks about his thoughts on client-side MVC: HTML is the model, CSS is the view, JavaScript is the controller.
  • (22:04) John says we’ve been figuring out of the past few years that it’s not okay to just throw JavaScript code up there until it works. He says he often surveys developers and asks how many of them have read a book on JavaScript with dismaying results. Scott says it’s not just a problem with disorganized code, you end up with resource management issues. Scott, John and Ward commiserate on the problems they’ve seen with sloppy code in long running JavaScript applications.
  • (24:31) Ward talks about the importance of good coding principles, especially the single responsibility principle. John says SRP is incredibly useful just about everywhere. Scott says he sees the same thing with testable JavaScript code.
• Hello World and Hello World scenarios
  • (26:37) K Scott asks if there’s a hello world style application when you create a new Hot Towel application. John says there is, but it’s absolutely minimal so that it’s actually useable as a starting point for an application. There’s no database. Ward says Hot Towel has two simple pages with just enough code to get you started; use the other SPA templates to learn about the frameworks, then build your real app with Hot Towel – if you’re going with a Knockout-based UI.
  • (28:37) Scott K says he sees Knockout and Angular cluttering your HTML in ways that violate some of the principles discussed earlier. Ward that you can do both without declarative HTML binding if you want. There’s a discussion of convention based bindings; K Scott asks if the Caliburn.Micro convention based bindings are used in Hot Towel, Ward explains why it’s not done.
  • (31:40) John talks about some poor practices he sees in Knockout demos which just throw in some JavaScript code after the bindings rather than just using a click binding or using delegation.
  • (33:32) Scott asks if we’d have imagined 10 years ago that we’d be writing JavaScript code.
  • (33:54) Ward says the thing that blows his mind is that we’re talking about a ToDo list like it’s rocket science. There’s a description of the canonical sample scenarios. Jon proposes the Contoso SPA, Scott talks about how everyone was writing blog samples a few years ago.
  • (35:43) John explains that he wrote Hot Towel so that you could use it without having to rip out a bunch of demo code; Ward says it also completes the stack, providing IoC, screen management, etc. The price tag of restructuring around composed JavaScript libraries is a lot of small files, figuring out AMD, etc. John and Ward praise Durandal some more.
  • (38:52) Scott K says there’s still a tooling problem with lots of injected JavaScript files. Ward and John say they don’t see that as long as they keep things organized.
• Getting started with SPA development
  • (40:27) K Scott asks for two things developers should do before getting started with SPAs. John says the first thing is to remember that you can apply your current good coding practices, the second is that you should treat the code as a real language and take advantage of patterns, especially the module pattern. Ward says use your intuition – if something smells bad, stop doing it and ask for help.
  • (43:03) John says don’t worry too much about which framework is the best, just pick one that feels natural. There’s a discussion of how the different frameworks have different feels, and you can just pick one and get started.
• Did Silverlight development experience help?
  • (45:15) Jon says he first encountered a lot of these issues in Silverlight development. John says yes, and explains how his skills applied. Ward says he can’t comment on how it’d have been for him if he hadn’t used Silverlight, but that if you do have Silverlight experiences they’ll definitely apply. John talks about his experiences with Code Camper.
• Can mere mortals create VSIX MVC templates?
  • (50:18) K Scott asks how difficult it was to create a VSIX based MVC template and if listeners could start with it. John says he waited for Ward to figure it and he copied Ward’s work, which wasn’t too bad. Ward explains what was difficult – mostly it comes down to poor documentation and duplicate references to files. He says he also hit issues with pulling in NuGet packages from multiple sources. Hot Towel is available as a NuGet package as well.
• Randomness
  • (58:11) The customary discussion of Ward’s wardrobe occurs.
  • (1:00:00) John talks about his upcoming PluralSight courses. Ward says he’s excited that BreezeJS was selected as part of the SPA story for ASP.NET and that he and IdeaBlade are focused on helping people as they’re getting started with Single Page Application development. 

Show Links:

• Ward Bell (blog, @wardbell, @wardbellsoutfit)
• John Papa (blog, @john_papa)
• Hot Towel template documentation on the ASP.NET site
• John Papa’s new Single Page Apps JumpStart course on Pluralsight
• Breeze – Build rich web apps in JavaScript with techniques you know
• Herding Code 111 – John Papa on the Open Source Fest at MIX11
• Herding Code 155 – Ward Bell on Single Page Applications and Breeze

Download / Listen:

Herding Code 160: Glimpse 1.0 release and Semantic Release Notes with Nik Molnar and Anthony vander Hoorn

Show Notes:

• Intro
• (00:38) Nik and Anthony remind us of what Glimpse does.
• High level: What have they been up to?
  • (01:27) Nik explains how they’re now sponsored by RedGate software, but it Glimpse continues to be an open source project under Apache 2 license. The end result is that they’re both able to work 40 hours a week on it.
  • Anthony talks about the change to remove the dependency on System.Web.dll, allowing for compatibility with ASP.NET Web API and OWIN.
• New features in Glimpse 1.0
  • (03:24) Jon asks about new features. Nik says they’re mostly at feature parity with the previous release, with a lot of key refactoring. Some new features include:
    • Support for SignalR
    • Routes are available in Web Forms
    • They can determine and surface route constraints
  • They’re working on MVC 4 support, System.Web.Optimizations, and Web API.
  • Anthony says the big goal of refactoring is to allow for fortnightly releases, which meant they needed to rework the core into something they could build on quickly.
  • (05:42) Jon asks about MVC 4 support. Nik says that everything in the MVC 3 package works, with the exception of Task based async support and newly added features like System.Web.Optimizations and Web API. Synchronous controllers and AsyncControllers work.
• Notifications, Semantic Release Notes
  • (06:25) Anthony talks about support they’ve added to work better with more frequent updates, including update notifications.
  • That got them thinking – can they also show more information about what’s in the update? What about plugin updates?
  • Nik talks about what they’re doing to pull information from NuGet about installed packages.
  • (11:08) Nik explains how the extensibility model uses an attribute which indicates that the plugin came from a NuGet package and indicates which version of the package it came from.
  • (12:12) They want to give you information about what’s changed between releases, which led them to Semantic Release Notes.
  • Semantic Release Notes are written in Markdown format, but include typed information (inspired by Todo.txt) which allows them to determine what’s changed between any two releases.
  • (15:45) Jon and Scott K ask about why they picked Markdown as opposed to some other formats. Nik explains a lot of reasons, including compatibility with any text based release notes system.
  • (17:20) This allows them to present "The Sports Center of Release Notes" which showcases the relevant highlights.
  • (17:40) Anthony says NuGet release notes are virtually unused because they don’t offer any value. They’ve been talking to developers who say they’d be happy to include release notes if they were actually useful.
  • (19:33) Nik says that another benefit of a text-based format is that it could be extracted from commit messages.
  • (20:20) Nik says that NuGet has raised the water level the experience of installing release notes, understanding what an update does, configuration, overall experience.
  • (21:28) Nik says that Semantic Release Notes could also inform developers of Semantic Versioning problems – e.g. if you’ve got a breaking change, you should be bumping the major version number.
• Problems with NuGet packages targeting product versions
  • (22:15) Anthony says they’ve run into some issues they’ve run into with NuGet. One issue they’ve run into is that developers often unwittingly install the Glimpse core package rather than the Glimpse.MVC package, which pulls in the core. They’re thinking about instead they could look at packages already installed in the project, determine that it’s an MVC project (for instance), and recommend installing the correct package (Glimpse.MVC in this case).
  • (26:00) There’s a discussion about problems to be considered with dependency scanning, notifying users, etc.
  • (27:55) Scott K asks about how this would work with locally hosted NuGet servers, MyGet, etc. Nik says they’ve seen a lot of cases of custom Glimpse plugins for things like e-commerce and internal information.
  • (28:55) There’s a MyGet feed with the nightly release, as well as a community feed for plugins.
  • (29:38) Scott K asks about how it works with local packages specifically.
  • (30:10) Nik talks about the problem with package explosion. NuGet allows you to target a specific .NET framework version, but not product versions. Jon asks why not just install Glimpse.MVC2, Glimpse.MVC3, etc. Anthony says this is a problem for any project that tries to factor things into a core with version specific dependant packages.
  • (34:28) Jon says they’re working hard to solve this problem, but would like to not have to. Anthony agrees: this is something he’d like see handled by NuGet itself.
  • (25:28) Nik says this is a growing problem, with examples from Windows 8 development. Jon talks about how he sees this problem in MVC 4. Anthony says he sees things moving in a good direction and that these are growing pains.
  • (37:25) Scott K asks if this is a problem that they’re seeing just because they have an ecosystem.
  • (38:40) Jon says he sees some people using VSIX instead of NuGet in cases where NuGet is limited. Nik says he’s frustrated that you can’t package up tooling – you can create a custom Web Platform Installer package at the high level, you can create a package.config at the project level, but there’s no solution for the installed tooling.
• Miscellaneous jibber jabber and future possible features
  • (40:55) Anthony talks about the problems they’ve run into with XML documents and Sandcastle.
  • (42:48) Jon asks about possible future features. Scott K he’d like to see a plugin for Fiddler. Anthony talks about how they’re in a unique position with insight into the entire request pipeline, from browser through server and back to the browser.
  • (45:30) Scott K talks about how OWIN support allows access to a lot of other web stacks, too.
  • (45:55) Nik says that they include the Glimpse request ID as a header now, so you can trace the request in Fiddler or other network tools.
  • (47:00) Anthony says they’re realizing that they can do a lot more than just surface troubleshooting information for people who are learning, talking about the potential for an extensible mini-dashboard which can show really intelligent information – e.g. inform me if a request makes more than three database calls.
  • (50:14) Jon asks if there are any plugins which analyze security. There’s a discussion about automated OWASP analysis.
  • (52:10) Anthony says they’re talking to Brendan Forster about displaying decision trees visually.
  • (54:54) Jon asks what they’re looking at doing long term. Nik says they’re looking at doing some monthly conversations for developers.
  • (56:14) Jon asks how people can get involved. Answer: go to GetGlimpse.com.

Show Links:

• GetGlimpse.com
• Semantic Release Notes proposal
• Herding Code 124: Anthony van der Hoorn and Nik Molnar on Glimpse
• Anthony van der Hoorn (@anthony_vdh)
• Nik Molnar (@nikmd23)
• Sandcastle Help File Builder
• OWIN: Open Web Interface for .NET

Download / Listen:

Herding Code 159: Catching up with Oren Eini on RavenDB

Show Notes:

• (00:47) Introduction and review of document databases and RavenDB
  • Oren gives us a quick overview of document databases and RavenDB
  • Relational databases work for the kind of applications we were building in the early ’90′s. We can kind of make them work in our current applications but it takes too much work.
  • RavenDB is a document database which stores JSON documents.
  • JSON documents can store arbitrarily complex data very easily.
• (04:35) Comparing accuracy and data consistency between document databases and relational databases
  • Jon asks about Oren’s comments on a recent .NET Rocks podcast in which he said that document databases allow us to be more correct than relational databases.
  • Oren gives a real life example of how an update to a customer’s financial information caused a change to her historical record, which caused some real problems.
  • Jon talks about some of the hoops we jump through in an attempt to maintain historical data in a relational database, e.g. soft deletes.
• (08:42) Disk space concerns
  • Scott K says he hears DBA’s worry about disk space due to data repetition between documents and asks what other concerns people bring up.
  • Oren says there can be more computation and indexing, but on the other hand temporal data is orders of magnitude easier.
  • Data design principles were established back when space was expensive, that’s all changed now.
  • Oren says he hears people say that space isn’t cheap in the enterprise, but runs some numbers and concludes they’re either very inefficient or someone’s got their hand in the till. Scott K says that enterprises data storage is often expensive because they’re not tiering their data correctly to put low priority data on cheaper storage.
  • Oren says enterprises drive up storage costs by due to foolish backup strategies.
• (14:42) Query and performance benefits
  • Scott K says that people often view document databases as a giant blob of text rather than structured data which can be searched, indexed, etc.
  • Oren says that you get full text search for free in RavenDB.
  • In relational databases, you’re always working with the very latest data, so you have locks, readers waiting for writers, etc.
  • RavenDB does a lot of precomputation in the background, so it can give you aggregate information immediately.
• (17:27) RavenDB 2.0 release overview
  • Big improvements to performance on some key codepaths, in some cases over 1000%.
  • Support for JavaScript scripts on the server, which allows for scenarios like mass migrations and batching support on the server.
  • Management UI improvement, better management API coverage, performance counters, etc.
  • Dev improvements – sharding support, full support for async.
• (19:40) 2.01 release overview
  • Files some rough spots in the 2.0 release – things that beta testers didn’t mind, but can be a little smoother.
  • They added a new feature – improves support for replicating to a relational database.
• (22:05) Sharding improvements and migrations
  • Sharding’s been around since the beginning, but required you to specify a lot of things – lots of options, too much complexity, too many important decisions early in the development process.
  • Sharding support has been revamped – provide the endpoints, defaults take care of the rest.
  • Oren gives an example with sharding customer data. By default, documents are sharded together based on transaction id. You can specify a shard when you save based on a user specified id.
  • Some people have problems with the default approach because the document id includes the shard id. That’s necessary to prevent having to query all shards.
  • Jon asks how this works over time if you need to add shards, migrate data, etc. Oren says you can rebalance by biasing new data towards a newly added shard.
  • If you need to move data to a new server – for instance, a customer becomes large enough that you want to put all of their documents on a new shard, you’ve got two options for handling the id’s. Oren says some users migrate data, rewriting id’s during the process, but he doesn’t recommend that. Instead, he recommends using a sharding function which allows remapping document id’s to a new shard without changing id’s.
  • Jon obviously doesn’t get it and asks the same question again, also asking how you handle data modifications over time. Oren explains that you can just write a JavaScript function to update your existing documents if needed.
  • Kevin asks how long data a data migration takes. Oren types one up on the fly and explains the parsing and execution time.
• (34:43) Time for some random questions!
  • Scott K notes that there’s a client that runs on Mono and asks if there are plans to get the server running on Mono. Oren talks about the general plan to handle that, but says it’s not high on the priority list.
  • (35:48) Scott K asks about compact scenarios, including clients that run on mobile and embedded instances that run locally. Oren notes that  clients are easy, because anything that can make a REST call can be a client. They had an embedded version that had very little interest.
  • (38:03) In disconnect scenarios, it’s usually simpler to cache JSON documents locally.
  • (39:10) Jon asks about merge support for occasionally connected scenarios. Oren says that’s intentionally not included.
  • (41:25) Jeremy Miller (@jeremydmiller) asks when Oren is going to fix Lucene.net’s flow control via exception madness. Oren says it’s not planned, and that Jeremy should ignore those exceptions.
  • (42:25) Philip (@autosnak) asks why RavenDB doesn’t do more for startups and small biz pricing-wise. Oren explains the offers they make available – open source is free, RavenDB basic edition is $5 / month, they donate a lot of license for a lot of other cases, and even the full versions are incredibly cheap compared with any other database. Shoot him an e-mail.
  • (44:44) Chris Whellams (@chriswillems) asks how to sell NoSQL and RavenDB to IT management and bosses that are addicted to SQL Sever. Oren outlines a strategy – start with a persistent viewmodel cache on a slow page to get a quick win, then use it for simple storage of ancillary application data (e.g. preferences), then use it in a spike on a new project. This is exactly what the MSNBC team did – they started with a non-operating RavenDB node in production, then slowly moved some things in without taking on any unnecessary risk.
  • (42:50) Jon asks for any closing thoughts. Oren says they’re starting on some weekly webinars for RavenDB users – or just if you’re curious about it. There’s a RavenDB course in the US in May.
  • FIN!

Show Links:

• Herding Code 83: Ayende Rahien on RavenDB
• Ayende’s Blog
• RavenDB 
• .NET Rocks 819 – Oren Eini Does NoSQL First

Download / Listen:

Herding Code 158: Nat Friedman and Joseph Hill announce Xamarin 2.0

Show Notes:

• (00:45) Nat begins by catching us up on Xamarin’s first eighteen months.
  • Xamarin’s focus is on helping developers build mobile apps across multiple platforms.
  • They have 230,000 developers in their community, adding 700-800 per day, with over 12,000 paying customers.
  • They’ve had top iPad (Bastion), music apps (Rdio) and some large mission critical line of business apps.
  • What’s special about their platform is that you can target iOS, Android, and Windows Phone, share C# code across  all those platforms, and still deliver a native experience.
  • Nat say’s they’re the overnight success that took ten years to prepare, referencing the ten years they took to build Mono.
• (03:20) Xamarin’s value proposition and customer base
  • Kevin asks which of their value propositions (.NET based development, cross-platform development) resonates more with users.
  • Nat says that many developers are initially attracted by C# development, although that’s not always the case (referencing an internal app at GitHub written by Objective-C developers who just liked sharing code between platforms).
  • Nat says there’s no real way to be a mobile developer now without having a cross-platform strategy – iOS might have looked like the only platform that mattered a few years ago, but now Android is more popular and Windows Phone is growing in popularity.
• (04:47) Code reuse strategy
  • Kevin asks how the code reuse happens, since these are true native applications.
  • Nat talks about different cross-platform strategies and says that they don’t believe in write once, run anywhere.
  • With Xamarin, you separate the backend and UI code and write specific UI code for each platform, although you still write it in C#.
  • Rdio has over 150,000 lines of code which are shared between iOS, Android and Windows which covers networking, caching, authentication, etc.
• (07:55) First big announcement: Joseph Hill announces support for building for iOS applications in Visual Studio.
  • Nat says that you can have one Visual Studio solution targeting iOS, Android and Windows Phone, and step through the code with the full debugging support you’re used to.
  • How does the Mac support work?
    • Scott K asks if this means that you have to run Visual Studio on a Mac. Nat says that’s not necessary, you just need to pair your Visual Studio instance with a Mac – it just needs to be on the network somewhere. That’s required both to be able to sign releases and to meet Apple’s license terms.
    • Jon asks if this would work with a Mac Mini, and Nat says that’s a popular option.
    • Scott K asks about a "Mac in the cloud" option; Nat says they’re not planning that.
    • Kevin asks if several developers could share one Mac. Nat says that Apple’s requirement is that each developer is supposed to have a license, and Joseph says that the Apple toolchain is build for single user rather than server support.
    • Jon ask if he can start playing with iOS support without having a Mac, Joseph explains that you can install and look around a bit, but you can’t build or deploy.
    • Kevin asks about the Interface Builder interaction.
    • Kevin asks if it was incredibly painful to set up this support for Visual Studio.
• (16:14) Second big announcement: Nat announces the release of Xamarin Studio.
  • Xamarin Studio runs on OSX, Windows, and Linux.
  • It’s based on Mono Develop, but it’s a completely new user interface with a lot of great new features.
  • Visual Studio Express users can’t install extensions so Xamarin Studio allows them to do Xamarin development, also it’s what all Mac users will be using.
  • Kevin asks if it’s a fork of Mono Develop.
  • Kevin asks if Xamarin Studio is open source.
  • Jon asks how it was developed. Joseph says it’s still C# Mono code using GTK. Developers write Xamarin Studio in Xamarin Studio.
  • K. Scott asks if you can target non-mobile scenarios. Joseph says you can still target ASP.NET, console, class libraries, etc.
  • Kevin asks what happens to Mono Develop. Nat says it continues as an open source project, and they’ll contribute back to it as they develop Xamarin Studio.
• (22:35) Xamarin as a Mono producer and consumer
  • Jon says it’s interesting watching the evolution of the Mono / Xamarin efforts as they’ve moved from supplying the Mono framework to being both building Mono and building a business on Mono.
  • Nat says it’s great working for a customer base rather than an opinionated crowd. "A really good signal that we’re doing good work is that people give us money for it."
  • Joseph talks about their model, explaining how their Xamarin business works well with their role as stewards of the Mono project.
• (25:28) Third big announcement: Nat announces the Xamarin Component Store
  • Nat says they see developers solving the same problems over and over again, giving an example of a common requirement for a signature capture control.
  • The Xamarin Component Store is a library of pre-built components. Nat gives an example of an Azure Mobile Service component.
  • It works in both Visual Studio and Xamarin Studio.
  • Components include documentation, screenshots, and sample projects. Nat says it’s conceptually similar to NuGet, but gives you a lot better experience and makes it easier to get started.
  • There are a lot of component vendors who are contributing both free and paid components, and Xamarin has also contributed several based on their experience in supporting Xamarin developers.
  • Jon asks how they handle cross platform, native user interface with components.
  • Kevin asks how people can submit components to the store.
  • Nat says he thinks this will really be a compelling feature of their platform, since developers won’t have to build everything from scratch.
  • Kevin asks they handle purchases and vender payments.
  • Kevin asks if the components are curated.
  • Jon asks about component support for Android and Windows Phone.
  • Kevin asks if it’s possible to create Xamarin components using native Objective-C components. Nat says they support both Objective-C and Java code reuse.
  • Jon says the design on the Xamarin Component store website looks great and asks about Xamarin’s approach to design. Nat says that they’re selling a good design experience and design is an important part of that.
  • Kevin says he like hover screenshots, Nat says he really likes the hover menu control.
• (39:35) Fourth big announcement: Nat announces the free Xamarin Studio Starter Edition
  • You can use Starter Edition to get started, build, and deploy applications.
  • Starter Edition is limited to 32KB of IL code.
  • Jon loves the idea of limiting the free edition based on compiled code size.
  • Kevin asks what kind of app will fit in 32KB. Nat says that using a lot of DLL’s will put you over the limit quickly, but images aren’t content. About 20% of the apps in the store would fit under the limit.
  • Joseph says they didn’t want to limit based on features. Jon talks about the frustration people see in Visual Studio version based feature limitations. Nat says pricing is hard; ultimately they want to get a lot of people using Xamarin and they think this is a good way to do that.
• (44:53) Jon asks about support for languages other than C#.
  • Nat says they see people using F# and Java (using IKVM).
  • Joseph says that C# is their main focus – all the documentation is in C# – but they’re happy to see people using other languages.
  • Kevin asks for JavaScript support. Nat says they think it’s hard to build large scale apps in JavaScript.
• (47:35) Nat talks about their upcoming developer conference.
  • The first two days are focused completely on training.
  • The second two days feature some great talks by community leaders, user interface designers, and more. The entire team will be on hand to answer questions.

Show Links:

• Nat Friedman (site, @NatFriedman)
• Joseph Hill (blog, @JosephHill)
• Xamarin
• Announcing Xamarin 2.0 (Xamarin blog)
• Xamarin Evolve – April 14-17, Austin, TX

Download / Listen:

Herding Code 157 – Amir Rajan on dynamic web development with Oak and Gemini

Show Notes:

• Overview – Developing with Oak
  • Oak is an approach to building single page applications that are heavy on JavaScript that takes a lot of inspiration from the Ruby community’s development approach.
  • Jon asks Amir to explain his development workflow, including SpecWatcher, NSpec, and Growl.
  • Jon asks about the File / New Project experience. Amir describes how that’s not even required – Oak works with WarmuP to build out a new project.
  • The next step is using Rake – Amir explains how Rake works. Running Rake builds the application and deploys, then sets up IIS against that instance.
• Dynamic programming and Gemini
  • Oak leverages the dynamic keyword. Amir explains how it just augments what’s already there in ASP.NET MVC.
  • Amir explains how Oak works with Gemini, separate library he’s built to enable building dynamic objects. It allows you to attach properties and methods through mixins. He gives an example of using Gemini to extend a dynamic object with validation methods.
  • Amir describes how Oak leverages Gemini to take advantage of these decorated dynamic model objects throughout the different layers.
  • Scott K asks where the composition happens – is this a pipeline process?
  • Jon says it sounds like this is a more fleshed out version of some dynamic features that were started in ASP.NET MVC, like dynamic views and ViewBag. He explains how Gemini goes beyond Expando, because it also includes support for method missing.
  • Jon says Gemini reminds him of the Clay dynamic objects used in Orchard.
• Data access and Cambium
  • Jon asks Amir about Cambium, the data layer. Amir says he customized Rob Conery’s Massive library to work with his Gemini objects, and points out that the resulting library uses remarkably little code.
  • Scott K asks Amir if he’s looked at Breeze. Amir says so far he’s just worked with standard ASP.NET MVC controllers, but he’s interested in looking at Breeze, Dapper, and NoSQL ORMs.
• But why?
  • Kevin asks the silly question: why bother bringing Rails idioms to ASP.NET MVC – why not work in Rails?
  • Jon says the thing he sees Amir’s done is eliminate the shift between development and runtime modes in Visual Studio based development.
  • Jon asks about change tracking support in Cambium.
• More about data – migrations
  • Amir explains migrations and schema generation in Oak and Cambium.
  • Amir says that SQL based migrations are important in many development environments.
• Single page and Ajax
  • Jon asks Amir about the Single Page Application story in Oak. Amir explains some of the points of friction that exist in ASP.NET SPAs and explains how Oak is able to round-trip dynamic types.
  • Scott K. asks why it’s so hard to migrate schemas in .NET. Amir says that it’s due to our fixation on trying to define our models using code first in .NET types rather than in the database.
  • Jon asks how the first deployment and upgrade scenarios work in Oak.
  • Jon asks how Ajax interactions work. Amir explains how this works using the TaskRabbit sample to explain.
  • Amir explains how he’s relying on client-side rendering and templating more and more. He asks if we’re seeing that movement as well, and Scott K. agrees with him. They agree that focusing on serving JSON and rendering on the client solves a lot of problems.
  • Jon asks Amir if he’s using one controller to serve HTML and JSON, or if they’re split out. Amir says he’s got one controller to serve the HTML, then does everything else via a separate controller that serves JSON. He says he’s noticed that the ORMs have very little need for state with this approach.
  • Jon says he’s seeing the shift from a little Ajax interaction in mostly HTML focused servers to servers that are almost completely focused on serving JSON.
• Some misc. questions
  • Jon asks about Canopy. Amir describes how Canopy is a stabilization layer on top of Selinium, and talks about why Canopy is built on top of F#.
  • Scott K. asks if Amir has looked at OWIN yet.
  • Jon asks about Async support in Oak.
  • Twitter question from Bobby Johnson: What do you do to limit the viral nature of dynamic in your code? Amir and Jon talk about how a lot of the assumed safety of static code is an illusion when you think about all the moving parts you’ve got no control over.
  • K. Scott and Scott K. think this is a fascinating project and like the code.
  • Scott K. and Jon joke about variants. Amir mentions that the dynamic nature of Gemini means that all the dynamic properties and methods are case insensitive.
• Wrap up and getting started with Oak
  • Amir talks about how to get started with Oak.
  • Jon says the sample apps, documentation and screencasts are really nice.
  • Jon asks what’s next. Amir lists a better SPA story, better file uploads, adding dynamic to ServiceStack and Nancy, and growing the number of Gemini modules.
  • Kevin asks about the performance impact of this dynamic focus. Amir that he’s got an included test, and he’s found that dynamic is actually faster in a lot of cases which need to use reflection, such as ORMs, JSON serialization, and model binding.
  • Amir calls out the NSpec project and references their interview on Hanselminutes.

Show Links:

• Amir Rajan (blog, @amirrajan)
• Oak: Frictionless development for ASP.NET MVC single page web apps. Prototypical and dynamic capabilities brought to C#.
• Oak project on GitHub
• Blog post introducing Gemini
• Clay: Malleable C# dynamic objects
• SpecWatchr
• Mighty Moose
• NCrunch
• WarmuP
• Rake – Ruby Make
• canopy: f# web testing framework
• Hanselminutes: Understanding BDD and NSpec with Matt Florence and Amir Rajan

Download / Listen:

Herding Code 156 – Catching up with Andreas Håkansson and Steven Robbins on NancyFx

Show Notes:

• Jon asks for a quick overview of NancyFx. Steve and Andreas both say you can write the same app on any number of web frameworks, so what really distinguishes them is the syntax and feel. Andreas says that the web only has a small set of things you really can do – there are only a few HTTP methods – but an infinite number of ways you can build applications; Nancy is one of them.
• Diagnostics
• Andreas says Diagnostics is a website built into Nancy itself. It covers things like request tracing and interactive diagnostics.
• Steve explains how the interactive diagnostics lets you find out what routes were hit and why, poke at live code, etc.
• Andreas says this works using companion classes for metadata which is then rendered via JavaScript templates, so you can customize it as much as you want.
• Jon says the code for Diagnostics seems like pretty good sample code for getting an idea of how Nancy code works.
• Jon asks about how authentication is handled to restrict access.
• Steve says they’re using Handlebars for JavaScript templates with Backbone and Nancy on the back end.
• Content Negotiation
• Andreas explains how routes just return models, and the formatting is handled by response processors. There’s a syntax to allow for more control at the route level if needed.
• Steve says the response processors are allowed to participate in the selection by specifying how applicable they are for both content types and model types. The content negotiation can also allow you to select different models based on the request, avoiding unnecessary code from executing and weighing the model down unnecessarily.
• Serializers and dependencies
• Jon asks about the JSON serializers they’re using, and why they’re not using something like ServiceStack or JSON.NET. Andreas explains that because the Nancy core ships without dependencies, they used Mono code.
• Jon asks about where Nancy can be be embedded, outside of standard web hosting scenarios.
• Steve says that because Nancy doesn’t have other dependencies and is strictly focused on returning a response for a request, it’s extremely easy to test.
• Andreas points out that you can use other serializers very easily via a NuGet package.
• Jon asks about how packages work in Nancy. Andreas explains how Nancy scans for classes that implement ISerializer.
• Kevin asks about implementing a processor for generating hyperlinks between models.
• Jon asks if people are sharing processors. Steve says that they’re so trivial to write that there’s no real point in sharing them.
• Localization
• Andreas says this was a community contribution. There are several conventions (including querystring values, URL segments) which can be used to set the culture for the context. There’s a helper on the Razor base class that returns a dynamic object which can return localized values from a resource. Assembly resources are used by default, but you can add others.
• Steve says that you can also use localized views based on filename.
• Jon asks for more information on how you’d set up a custom resource location.
• Architecture, pipelines, and IoC
• Jon says that he spoke with Jeremy Miller at Codemash, and Jeremy said that it took a while to get the processor architecture set up, but now it’s very easy to add in features. It seems like that’s also paid off for Nancy. Andreas agrees, the pipeline system and dependency injection really simplify adding in new features.
• Jon asks about how Nancy uses TinyIoC and how you could use TinyIoC in other applications.
• Kevin and Jon ask about how Steve wrote TinyIoC to run on multiple platforms. Steve describes some issues they’ve worked around and how assembly scanning can get tricky due to test frameworks injecting things into the app domain.
• Non-standard uses of Nancy
• Jon asks for some examples. Steve says they seen people embed it into WPF applications for an interface, to provide mobile support, and even on Raspberry Pi. They’d love to hear more about what people are doing with it.
• Questions from Twitter / Misc. Questions
• Jim Liddell (@liddellj) asks about the roadmap. Steve talks about work they’re doing for OWIN and Async support.
• Filip W (@filip_woj) asks "Why tuples instead of classes and structs?"
• Kristof Claes (@kristofclaes) asks "How do they determine when something is "too much ceremony"? Gut feeling? Set of defined rules? Talk? Compare to other FX?"
• Ian Battersby (@Cranialstrain) asks "Why dynamic? And don’t say fluency ;)"
• Tobi Tobsen (@t0bit0bsen) asks "Is there a NancyFx tutorial for devs w/o a background in web development or should they look elsewhere?"
• Jim Liddell (@liddellj) asks "How do you view Nancy in relation to similar frameworks, such as OpenRasta?"
• Kevin asks about asset management for Nancy. Steve says that’s probably better handled by external
• Kevin asks about web socket support. Steve says just use SignalR.
• There’s a Nancy store now.
• Daniel Lee (@danlimerick) asks "How many hours a week do you spend on Nancy? What’s ratio of reviewing PR’s vs writing new features?"
• Jon asks what Steve and Andreas are finding fun and interesting lately. Steve and Andreas both like Mongo.
• Scott K. asks if they’ll add time zone localization support. They tell him to submit a pull request.

Show Links:

• NancyFX git repo, NuGet package, Google Group, @NancyFx
• Andreas Håkansson (@TheCodeJunkie)
• Steven Robbins (@Grumpydev)
• Herding Code 123: Andreas Hakansson and Steven Robbins on NancyFx
• TinyIoC

Download / Listen:

Herding Code 155 – Ward Bell on Single Page Applications and Breeze

Show Notes:

• General SPA discussion
  • Ward talks about how IdeaBlade has been building tools for working with data in rich clients for a while, and after seeing the move towards desktop experiences in the browser they started the Breeze project, which is open source and free.
  • Jon asks Ward to define single page applications (SPAs) a bit, and Ward says he sees SPA as a funny term since it just describes one attribute of the experience – it’s like calling a car a “horseless carriage.” Ward says the goal is to give the user a rich experience and not rely on the server to deliver that rich experience. A lot of the value comes from maintaining data and state on the client.
  • There’s a discussion about the value and best applications of SPAs.
  • Kevin says there are a few aspects of SPAs – there can be a lot of individual, interactive pages which are separately delivered by the server, or you can have a more full application which handles screen transitions on the client. Ward talks about the tradeoffs of the two approaches. The whole SPA application approach is especially important in newer scenarios like mobile or Window Store applications built in HTML/JS.
  • Scott K asks about the different approaches to data loading – do you preload some of the data, or does the first page request just deliver an HTML client which requests all the data.
  • Scott K asks how often Ward sees offline manifests and local data. Ward says he sees things going that way, but it’s still early. Scott K and Ward talk about the difficulty of synchronizing offline changes when you’re reconnected.
  • Scott K and Ward talk about the use of Web Sockets and / or SignalR to handle locks to allow for multiple users.
• Breeze
  • Jon asks Ward how Breeze helps
  • Ward says that they’re not trying to solve solved problems – they’re focused on solving the data problem.
• Breeze, Upshot, and the ASP.NET SPA template
  • Jon asks how this fits in with the former ASP.NET SPA template and Upshot. There’s a discussion the history and state of Upshot and RIA Services.
  • Scott K asks about whether Upshot will be released as open source… or the unreleased ASP.NET MVC Recipes source. Jon starts crying.
  • Jon and Ward talk about how one of the big features of Upshot was that there were both client and server side parts to it.
  • Ward said they’d learned from the Upshot, so they made Breeze very extensible while making for an easy path when using ASP.NET Web API and Entity Framework.
  • Ward says the current ASP.NET MVC SPA app is too simplistic, because it’s just one simple screen.
• Working with Breeze – client state, server-side interaction
  • Jon asks Ward about how Breeze handles local state. Ward describes how the server can send down metadata (likely from an Entity Framework model) to the Breeze client code so it can understand the models, relationships, validation rules, etc. You can extend things if you need to, but you don’t need to bother with the tedium of creating client models that match your server-side models.
  • The generated client-side models are ready to be hooked up to Knockout so they’re easily bound to the UI.
  • Jon asks how things are different on the server. Ward says that standard ASP.NET Web API controllers are very repetitive – each controller has GET, PUT, POST, DELETE methods that are just boilerplate. Pretty soon you end up with thirty API Controllers which just contain a lot of boilerplate code. Breeze can just expose things as Queryables so you really just need one controller unless you want to customize things. Scott K says it sounds like it’s basically Repository<T>. Scott K says he’d like to see it go further – at Cascadia there were some talks about big data where queries were created on the client and sent to the server.
  • Jon and Ward talk about the difficulties of complex repetitive APIs with too many entry points.
• How Breeze fits in with other frameworks like Ember, Angular, Backbone, etc.
  • Jon asks how Breeze fits in with Ember, Angular, and other SPA frameworks. Ward talks about different framework philosophies and how Ember and Angular both more of top to bottom stacks. Kevin mentions how Backbone differs – it’s more of a library vs. a framework.
  • Ward says that Breeze really targets the data scenario. Jon asks how close its vision is to Upshot’s. Ward explains how, other than Ember Data, nobody’s looking at solving the data scenarios – they don’t worry about caching, object graphs, change tracking, etc. Scott K says the other frameworks are really MVC focused, so they don’t consider data.
  • Scott K asks what happened to Batman.js. Nobody knows.
  • Jon asks if the happy path for Ember is Rails focused and Breeze is ASP.NET / Entity Framework focused. Ward says yes, with a clarification that we’re really talking about Ember Data.
• Getting Started
  • Jon asks if it’s difficult to get started with Breeze.
  • Ward talks about the NuGet package that gets a sample project set up quickly.
  • Ward talks about the live tutorial that lets you play with Breeze in a browser.
  • Ward talks about the automated tests they’ve got for Breeze training. Jon compares it to Ruby Koans.
• Jon, Ward, Kevin and Scott K talk about automated JavaScript testing options – Chutzpah, QUnit, Jasmine, Mocha.
  • Chutzpah is an automated JavaScript test runner that can run inside of Visual Studio.
  • QUnit is pretty simple – tests are functions that take true or false.
  • Jasmine is more BDD style.
  • Mocha is a test framework that supports different front ends, so you can use BDD, standard unit testing, etc. It’s also got great async support.
• Ward brings up TypeScript and Scott Koon starts cursing.
• Wrap up small talk
  • Jon says that the talk about mocha reminds him of coffee, and he asks Ward about his new espresso machine. Jon and Ward both get their coffee beans from Sweet Maria’s.
  • Jon says he’s still roasting his coffee on his barbeque.
• Scott K asks what dependencies Breeze has. Ward says they write to EcmaScript 5 and have gotten rid of all dependencies other than one called Q.
• It’s time for Pimp Yo Stuff, and Jon takes the occasion to praise Ward’s sartorial skill. Scott K says they’d like to
  • Ward pimps the DevForce and and Cocktail combination. Cocktail is DevForce + Caliburn.Micro.
  • Jon asks about the license for Breeze. Ward clarifies that it’s all free and open source, and they make their money on support and professional services.

Show Links:

• Ward Bell (blog, @wardbell)
• Breeze – Build rich web apps in JavaScript with techniques you know
• Ward’s post: The SPA as a Horseless Carriage
• Backbone.js
• backbone.stickit – yet another model-view binding plugin for Backbone
• AngularJS – “what HTML would have been, had it been designed for building web-apps”
• John Papa’s Code Camper tutorial
• Ruby Koans
• Chutzpah – A JavaScript Test Runner
• QUnit – JavaScript Unit Testing framework
• Jasmine – a behavior-driven development
• Mocha – a feature-rich JavaScript test framework running on node and the browser, making asynchronous testing simple and fun
• Sweet Maria’s – Home coffee roasting supplies
• q – A tool for making and composing asynchronous promises in JavaScript
• Caliburn.Micro
• DevForce
• Cocktail
• Leroy’s Menswear
• Herding Code 104: Rob Eisenber on Caliburn.Micro
• Herding Code 57: Presentation Patterns with Jeremy Miller, Ward Bell, Rob Eisenberg and Glenn Block (Part 1)

Note: The audio is a bit crackly in a few parts, but just for a few seconds.

Download / Listen:

Herding Code 154 – Aaron Stannard on MarkedUp, founding a startup, and Windows 8 development

Show Notes:

• Jon starts by asking Aaron about what led him to founding a startup. Aaron explains how his first startup failed and his blog post about Why .NET Adoption Lags Among Startups got him a job as a startup evangelist at Microsoft
• Opportunities: Windows 8 development and MarkedUp
  • Aaron explains how he saw a key opportunity around the Windows app ecosystem and why the teaming seemed right to really dive into this now. Jon agrees that this is a really interesting time in the Windows developer landscape.
  • Aaron explains that MarkedUp delivers in-app analytics for WinRT and eventually Windows 8, answering questions like how many people use your app every day, how much time they spend using it, which features they use, and what in-app purchases they make.
  • Jon mentions a key difference in the Windows Store which allows you to have one app which can be upgraded from free to paid, whereas other platforms have duplicate applications for free and paid.
  • Aaron talks about his recent blog post comparing iOS economics vs. Windows 8 economics titled Win8 Developers: Don’t Make the Terrible Mistake of Treating the Windows Store like the iOS App Store. He explains that there’s an opportunity for Windows 8 applications to do quite a bit more than simple little hit driven apps, and Windows 8 applications can and should do quite a bit more.
  • Aaron talks about the pricing model – free now, there will always be a free model, and it’s intended to be pretty reasonable for developers with successful applications.
• Tech talk about WinRT development and how MarkedUp integrates therewith
  • Aaron begins explaining the technology stack, but Jon interrupts him to ask him to explain what a .winmd file is. Aaron discusses some of the key similarities and differences between WinRT and .NET development.
  • Aaron talks about how they’ve cleaned up a lot of the information that’s exposed so it’s useful.
  • There’s NuGet package you add to your Windows 8 application which brings in the .winmd dependency.
  • There’s a managed singleton approach which handles a lot of things automatically, like application startup and shutdown. You can also log additional events through the managed singleton.
  • There’s a JavaScript wrapper that sits on top of the .winmd file for WinJS applications which flattens some of the hierarchies and namespaces for logging.
  • Aaron says he’s seen this as a common pattern for Windows 8 development – write some .NET code, ship it as a .winmd file, and provide a JavaScript wrapper for WinJS.
  • Aaron mentions that he likes this pattern for application development, too: write business logic in C# and expose it through .winmd put a JavaScript wrapper on top of it to write the interface in HTML and CSS. He like the flexbox and grid system for layout, and thinks the CSS3 media selector based layout orientation systems is a lot simpler than trying to do that in XAML.
  • Aaron explains that as an analytics component, they will never degrade the user experience, so they’ll always swallow internal exceptions.
  • The communications system is also designed to prevent impacting the user, so they cache locally and only send a single message at a time.
• RavenDB and how it compares with other document databases like MongoDB
  • Data is stored in RavenDB. They evaluated both RavenDB and MongoDB but decided RavenDB worked better for them at this point. He describes some differences between RavenDB and MongoDB.
    • RavenDB projections make it easier to do server-side transforms.
    • RavenDB has some nice batch loading features.
    • RavenDB lets you express map-reduce as a pre-computed index.
    • Aaron doesn’t like the way sharded RavenDB clusters work.
    • They’re probably going to go to Cassandra or HBase eventually.
    • Aaron talks about a solution (Hircine) they came up with to precompute RavenDB indexes at build time rather than startup.
    • RavenDB is great for unit testing
  • Aaron talks about their build system using Albacore and talks about their build and deployment system.
  • Jon asks about why they’re planning to move from RavenDB to Cassandra or HBase. Aaron says he doesn’t like the scale-out / sharding system in RavenDB and doesn’t think it will work for them as they scale. Aaron talks about their plans to handle complex analytics at scale.
• Jon shifts gears to ask about starting a company. How do you get started?
  • Aaron talks about the history of how they got started – with a mission.
  • Next questions: Am I the right person to execute this? Is this a problem worth solving? Is this economically viable?
  • Build a minimum viable product and show it to people you trust. Aaron gives examples from the history of starting MarkedUp, with an application that let you annotate and upload screenshots from iOS. Jon and Aaron discuss how Aaron was able to do most of the minimum viable product development without quitting his job.
  • First step in actually starting the company: talk to a lawyer to get your structure and ownership figured out.
  • How do you make the decision to go fulltime?
  • Figuring out how to pay the bills: can you monetize quickly, or do you raise money?
  • Aaron talks about the process of getting funded and networking with potentials investors.
  • It’s an emotional rollercoaster – be ready to change tactics, but don’t quit.
  • Jon and Aaron talk about the benefits of doing this all incrementally – at least until you go full time.
• There’s a registration URL for Herding Code listeners (https://markedup.com/account/register/?utm_campaign=herdingcode) – or you can just go through registration and enter the code HERDINGCODE into the registration code field on the form.
• Aaron says he’d be happy to talk with other developers who are interested in the startup process.

Show Links:

• Aaron Stannard (blog, @aaronontheweb)
• MarkedUp  (@MarkedUpMobi)
• .NET Culture Shock: Why .NET Adoption Lags Among Startups
• Win8 Developers: Don’t Make the Terrible Mistake of Treating the Windows Store like the iOS App Store
• Router .CoCPit application
• RavenDB (Herding Code 83: Ayende Rahien on RavenDB)
• Cassandra
• HBase
• Hircine: Stand-alone RavenDB index builder, used in CI systems and automated deployments
• MarkedUp registration link for Herding Code listeners

Download / Listen:

Herding Code 153 – Matt Wrock on RequestReduce, Chocolatey and BoxStarter

Show Notes:

• RequestReduce
  • Matt explains how he got started with RequestReduce – a site optimization system that’s been designed as a plug-and-play system that can work well with legacy sites without any code changes.
  • Matt explains how RequestReduce fits in with other systems like the ASP.NET Web Optimization system and Casette.
  • K. Scott asks Matt how it works and how a user would configure it. Matt explains how it can be installed via NuGet, and how it uses a Response Filter to process the output.
  • Matt explains how everything’s handled via a queue on a background thread, so there’s no performance impact on initial requests.
  • RequestReduce pulls in CSS, images and JavaScript so it can work with remote content and CDNs.
  • Matt gives a shoutout to AjaxMin and the speed at which he and Ron Logan have been able to turn around fixes and improvements.
  • Matt explains the complications involved in creating image sprites, and why he only sprites images with a defined width.
  • Matt explains how both quantization and compression can dramatically affect image size.
  • Matt explains why he doesn’t sprite images when he can’t determine the image width.
  • Scott K talks about his previous job and how they’d looked at converting all images to Base64. Matt says that he’s looked at that, but decided it’s not something you’d necessarily want to apply to all images.
  • Jon asks Matt to explain CSS spriting in more detail. Jon says they use sprites on the ASP.NET site, and Matt says the ASP.NET site is one of his test case sites.
  • K. Scott asks Matt why the code is calculating CSS specificity scores.
  • K. Scott asks about what the results have been. Matt says it varies by site, but on one large site they’ve seen a 33% improvement.
  • Jon mentions that RequestReduce also handles Less and CoffeeScript. Matt says he’s making use of SassAndCoffee.
• BoxStarter and Chocolatey
  • Matt talks about how he got started with BoxStarter – he was tired of wasting time building development boxes, and he didn’t think VMs were a good solution.
  • Matt thought Chocolatey solved some of the program installation issues, but didn’t handle common customization scenarios like Windows settings, file associations, taskbar links, path, etc.
  • Chocolatey handled some of the things Matt wanted, but not everything. He started by customizing and wrapping Chocolatey, but decided it would be better to contribute directly to Chocolatey.
  • BuildStarter can work with either a local BuildPackages folder or a custom MyGet feed.
  • Matt says he might like to use ClickOnce in the future.
  • Matt talks about how he’d like to have a web based shopping list approach, where you could just click off all the things you wanted and it would set up a package for you – kind of like like Ninite, but a lot more comprehensive.
  • Jon says he was happy to see a recent Chocolatey commit that can turn Windows features on and off.
  • Matt explains how he’s been coordinating with Rob Reynolds to decide what he should contribute directly to Chocolatey and what should be separate Chocolatey packages.
  • Jon says he didn’t get Chocolatey right away, but what sold him on it was the dependency management. Matt explains how this has come in handy in his work in the TFS dev team.
• TFS
  • Jon asks Matt about his work on new role on the TFS team. Matt says he’s working on the REST API for work item tracking and would love any feedback on work item tracking.

Show Links:

• Matt Wrock (blog, @mwrockx)
• RequestReduce
• Casette
• SassAndCoffee
• BoxStarter
• Chocolatey
• Rob Reynolds (@ferventcoder)
• Herding Code 128: Rob Reynolds on Chocolatey and the Chuck Norris Frameworks
• Herding Code 118: Paul Betts on SassAndCoffee

Download / Listen:

Herding Code 152 – Josh Twist on Azure Mobile Services

Show Notes:

• How Azure Mobile Services got started
  • Jon asks Josh how he got involved with Azure Mobile Services.
  • Jon asks Josh about the Zumo code name – ZU from Azure, MO from Mobile.
  • Josh explains how things got off the ground with a real startup feel.
  • Steve Sanderson was a dev on the team, working on the interactive portal experience.
  • Jon asks about platform support. Josh says that Windows 8 was the platform that was initially announced at launch, but other platforms are on the way very soon.
• The three personas the Azure Mobile Services
  • The hobbiest app developer who have very limited time and wants to spend the time on their mobile clients, not the backend services. Jon talks about the experiences he had on The Full Stack project with Jesse Liberty.
  • The client focused developer is working full time on a mobile application, but still wants to focus on the application rather than the backend – and wants to make sure that it’s going to scale when needed.
  • The veteran backend developer, who is very comfortable with building services. Josh says these folks are already pretty well served with existing Azure services.
  • Josh says that Azure is primarily focused at the first two personas – developers who want to focus on the client applications and have the back end just work.
• Jon asks about an example – a social game where he can invite friend to play a game, track high scores, etc.
  • Josh lists out some of the features  Jon would probably want – authentication, structured storage, push notifications, etc.
  • Josh describes some of the challenges Jon might run into and how Azure Mobile Services handles extensibility by allowing for server-side scripts, written in JavaScript.
  • Jon asks Josh about the identity provider story.
  • Jon asks if the server-side JavaScript scripts use Node.js.
• Josh talks through a to do list sample application.
• Jon asks about how the client libraries will likely look on other platforms like iOS and Android.
• Data
  • Jon and Josh talk about the data story.
  • Josh explains the dynamic schema system.
  • Jon asks handling hierarchies in data. Josh says not yet, although you can use scripts to handle that.
• Lots of random questions time!
  • Jon talks about a blog post on accessing the Azure Mobile Services via the REST services. Josh says that’s great, encouraged, and you can use that approach to use Azure Mobile Services from all kinds of frameworks and platforms, mentioning several examples.
  • Kevin asks about handling the scripts as production code – can it be under version control? Josh says that’s in the works. They’re also thinking about the packaging story, to allow for exporting services and moving them between environments.
  • Kevin asks if there’s a migration path if you hit limits in Azure Mobile Services. Josh says that you’d handle this through composition with other services, but they’re looking for feedback for things they can add via service and script support.
  • Kevin asks how the billing works. Josh says you pay for what you use, so you pay for the underlying services you use. You can get 10 free instances, but can pay to scale up if you want.
  • Kevin asks about their experiences in building with Node.js. Josh explains how the runtime runs on Node, but the service management uses ASP.NET Web API. They mainly picked Node.js to allow for server-side scripting using JavaScript.
  • Jon asks if there’s a way to run locally for testing. Josh says not yet, but definitely something they’re think about.
  • Jon asks about concurrency support.
  • Kevin asks about monitoring and troubleshooting support. Josh lists out some of the realtime dashboard features.
  • Jon asks about other configuration options in the Azure portal. Josh lists a few – authentication, data, etc. – but says the goal is to keep things simple.
• Relationship of Azure Mobile Services with Azure Web Sites and Azure in general.
  • Jon asks about the relationship to Azure Web Sites. Josh explains how they worked with the Azure Web Sites team to get sandboxing. They’re running on a special version of the Azure Web Sites system that’s specially tuned for their services.
  • Jon asks about scaling with Azure Mobile Services. Josh educates Jon on some Azure basics he really should know.
• Jon asks Josh about how listeners can get started.
  • Josh list the link: http://aka.ms/mobileservices
  • Josh and Jon joke about the todo list quickstart challenge. Josh says new users should be able to have an application running in under 5 minutes, and Jon says he was impressed with Josh’s performance on Cloud Cover: 2:03 despite heckling.

Show Links:

• Josh Twist (blog, @joshtwist)
• Azure Mobile Services – free trial
• Steve Sanderson
• Cloud Cover Episode 89 – Windows Azure Mobile Services
• Blog post by Filip W. (StrathWeb): Using Azure Mobile Services in your web apps through ASP.NET Web API
• Web Camps TV interview: What Mobile Services Mean To The Web Developer

Download / Listen:

Herding Code 151 – Rob Eisenberg on RPGWithMe, Durandal, and XAML vs. HTML5 development

Show Notes:

• RPGWithMe and Durandal
  • K Scott asks Rob to discribe RPGWithMe. RPGWithMe is a subscription based web product for playing tabletop RPGs.
  • K Scott asks how he found HTML5  compared to XAML development, and whether he used any frameworks to develop it. Rob explains how he built a new framework, Duandel, to bring Caliburn.Micro style development to HTML5 development.
  • Rob explains how Durandal uses  RequireJS to modularize things – viewmodels are mapped to modules, and modules are mapped to HTML files. Knockout is used to compose things at runtime, and RequireJS packages things up into a single file.
  • Jon asks it it’s possible to use this with WinRT. Rob says he hasn’t tried it, but thinks it should work since it’s just a JavaScript file.
  • K Scott asks if the same conventions in Caliburn.Micro apply. Rob says he’s just using Knockout at this point, but would eventually like to phase out Knockout for a custom databinding system. Knockout’s fine, but he doesn’t like the syntax for databinding and the intrusiveness into viewmodels.
  • K Scott, Rob and Kevin talk about the intrusiveness of Javascript frameworks which convert properties to functions to allow for observability, and how newer browsers can wrap getters and setters to imporove the code readability and debugging experience.
  • K Scott asks whats on the server side. Rob’s using ASP.NET MVC 3 running on AppHarbor with cloud hosted RavenDB with IronMQ and some Amazon services.
  • K Scott asks how all the realtime stuff is working in the browser. Rob’s using PubNub for communications and Canvas and CSS 3 for rendering. He explains that it’s really tricky to get high performance, high quality graphics rendering working on different devices with an interesting example form an issue he hit with larger images on iPads.
  • Jon asks if there’s work he’d do in the future to support Retina / high dpi displays. He says he’s moving away from images to CSS 3 where possible.
  • Jon asks about the creation / editing environment. Rob explains how the system is built around user generated content. Jon asks if there are ways
  • K Scott asks what games Rob’s played in the past. Rob says he’s played Dungeons and Dragons 4th Edition and Savage Worlds and explains some of the background of tabletop role playing games. He supports three gaming systems, but doesn’t enforce rules – this allows for a lot more flexibility and matches the way people play in the real world.
  • K Scott asks about how players would communicate while playing (e.g. to yell Leroy Jenkins!).
  • Jon asks more about rules and enforcement, and Rob lists a lot of reasons why he doesn’t think it’s a good idea to get into rule enforcement.
  • K Scott asks about how the metadata is handled. Rob describes how he’s got an abstract model that allows for supporting – and importing from – three gaming systems, and how he wants to make it more extensible in the future.
  • Kevin asks if there’s a mobile version. Rob talks about platform support – works on iPad, Windows 8, and Android although Android performance is the worst.
  • K Scott asks about the Durandal project out on GitHub.
• Caliburn and Caliburn.Micro
  • K Scott asks Rob what’s going on with Caliburn and Caliburn.Micro. Caliburn.Micro is adding full support for WinRT and considering how to add support for additional WinRT features. He said he was worried about porting to WinRT but it wasn’t too bad – most of the work was around changes to the reflection API and lack of behaviors. He’s hopeful that this means it’ll port to Windows Phone 8.
• XAML and HTML5 development
  • Kevin asks about Rob’s frustration on building tools for XAML development due to the differences between the platforms. Rob says he’s been moving to HTML5 more due to all the headaches.
  • Jon wonders if some of this may be transitional with things moving to WinRT as a standard XAML platform. Rob agrees, but he’s got from fatigue from all the times he’s had to port his code in the past.
  • Jon says that it’s nice that in the HTML5 world you can use tools like jQuery to abstract differences between browsers, whereas you can’t really do that when working about different XAML platforms. Rob talks about how people are trying to abstract things in the XAML world, but it’s not really possible to abstract platform differences.
  • Jon, Kevin and Rob discuss the differences between styling in XAML and HTML5 development.
  • Jon asks Rob about the developer decision between HTML5 and XAML for WinRT development. Rob’s happy with the choice, and thinks it’s funny that Microsoft did this rather than Google.
• K Scott asks Rob if there’s any new big things going on he wants people to know about, and Rob mentions the Kickstarter effort to add interactive character sheets.

Show Links:

• Rob Eisenberg (blog, @eisenbergeffect)
• Blog post: Today..All Your Wildest Dreams Come True
• https://github.com/EisenbergEffect/Durandal
• PubNub
• AppHarbor
• Knockout
• Caliburn.Micro changeset adding WinRT support
• Kickstarter: RPGWithMe: Create Characters for Your Tabletop RPG

Download / Listen:

Herding Code 150 – David Starr on the People, Practices, and Tools of Development

Show Notes:

• From Nascar to Scrum.org to Microsoft
  • K Scott outs David as a developer of the original NASCAR site.
  • David’s been working with Scrum.org but just took a job at Microsoft in the Visual Studio team as a senior PM based on his interest in executable specifications.
  • K Scott asks David about his thoughts based on working with Scrum.org. David sees Scrum as nearly ubiquitous, but most just use it as a way to manage daily checklists rather than effect broader change.
• SubSpec and executable specifications
  • K Scott asks David about his recent post on SubSpec and how it compares to SpecFlow.
• Software code of ethics
  • K Scott asks David about his post thinking about a professional code of ethics for software development.
  • David thinks it would be nice if we had a profession.
  • Jon asks if this kind of approach is even relevant to a lot of most software developers.
  • Scott K mentions a discussion on the show a few years ago about board certification but wonders who would run it.
  • David says that any certification offered by a tool vendor or methodology proponent is worthless.
  • Scott K asks if there’s any overarching certifiable skills that bridge Ruby, Scala, Java, .NET, architecture, development, etc. David says that in other trades it’s unions that push things, but doesn’t want that in the software world.
  • Jon says that he sees so much disagreement on values between languages and methodologies that he wonders if our profession could agree on anything at all.
  • Scott K asks if software really is a craft, as he doesn’t  see beauty in code. David says he doesn’t see code as words but as shapes. Scott K, David and Jon discuss where the beauty really is – perhaps not the code, but the result.
• Jon asks how these discussions and values tie into Visual Studio tooling.
  • David says that tooling is a great way to take the kinds of things bleeding edge developers are excited about and turn them into things that are accepted and used by the broader community – as long as the hierarchy of people over process and process over tools is respected, it’s a great idea to make better tools.
  • Scott K asks what he sees are the most important things to fix in the tooling. David says he’d like to see development teams modeled as teams rather than differing roles. He’d like to improve the experience for the “specializing generalist.”
  • David says that he sees the tools making the rules in the real world, and if the tools are counter to our value systems we should change that.
  • Scott K says people might just be fooling lights to green and David says that’s a fireable offence. Jon asks if it’s possible to automate that by integrating TFS with Microsoft CRM.
• Jeff Schumacher asks if he still has the awesome fire shoes.
• The Code Junkie asks why someone should pick TFS over the other options when doing agile / scrum.
• Brian Lagunas asks  what are the downsides of TDD.
• There is a frightening discussion of a theoretical XamlSpec testing framework.
• Scrum effectiveness
  • Paul Stack whether scrum has become a make believe methodology companies use to pretend they’re agile.
  • David says methodologies are always abused. He likes to tell people to try scrum by the book for a few months before making changes or compromises. Jon says every company wants to believe they’re different, and that’s rarely something to cling to.
  • Scott K says he sees people focusing on tooling and this leads to “scrumbut” – the practice of doing scrum, but… David says he really tries to avoid that term – scrum is a tool.
  • Kevin says he sees Scrum as a project management methodology as opposed to XP which also focuses on the engineering side. David says that you can’t be successful separating Scrum from good technical practices.
• David talks about his last user group presentation before moving, says he’s not going to be travelling as much in the near future, and conversation drifts back to XamlSpec as the most useful result of this discussion.

Show Links:

• David Starr (blog, @elegantcoder)
• Nascar.com in the internet archive
• Scrum.org
• SubSpec
• SpecFlow
• Redwood City, CA
• David’s blog post: SubSpec
• David’s blog post: Software Professional Code of Ethics

Download / Listen:

Herding Code 149 – What I Did With My Summer Vacation

Show Notes:

• Travel
• Jon asks starts by asking where everyone’s been travelling to over the summer.
• K. Scott’s basically a European at this point.
• Jon went to Oslo, Buenos Aires, Sao Paulo, Redmond, and rural New Jersey, and Kevin survived a road trip with kids thanks to iPads. Jon really liked Buenos Aires. He talks about his Web Camps presentations in South America, including a Windows Azure Web Sites talk where he builds and deploys a classic ASP app via FTP, ASP.NET / SignalR app via Visual Studio Web Deploy, a Node.js app via git publish, and a WordPress site via WebMatrix deploy in one hour. He’s amazed by how translators can listen to obscure technical jargon and speak in another language at the same time, including prompts about when the audience should politely laugh at a failed joke.
• Kevin survived a road trip with kids thanks to iPads.
• e-book reading devices
• Scott K has been running the CyanogenMod Android ROM on his Nook Color.
• There’s some discussion on the benefit of a 7" form factor device and rumors about a 7-ish iDevice on the way.
• Jon and Kevin love their Kindles, and Scott K talks about what he likes about the Nook Color.
• Scott K mentions O’Reilly’s Bookworm site, which was sadly closed down as of March 31.
• Jon has stayed with the Kindle eInk devices for the read aloud support, which is sadly missing on all the other top ebook devices. Kevin like the long battery life.
• Book Reports
• Jon kicks off book report time mentioning The Door into Summer and The Code Book: The Science of Secrecy from Ancient Egypt to Quantum Cryptography
• Scott K has been reading The Hobbit: 75th Anniversary Edition and The Geeks Shall Inherit the Earth: Popularity, Quirk Theory, and Why Outsiders Thrive After High School.
• Kevin read Snow Crash and Ender’s Game
• Jon kind of liked Reamde: A Novel but doesn’t like it as much as Cryptonomicon.
• Geek Travel Tips
• Jon and K. Scott use a checklist to make sure they don’t forget important things like chargers and adapters.
• K. Scott doesn’t assume anything and keeps a small bit of foreign cash handy.
• Jon and K. Scott both really like TripIt.
• Jon talks about how he handled a cancelled flight to Buenos Aires by calling in (rather than waiting in line) and being nice.
• Jon and K. Scott both avoid checking bags when possible.
• Two factor authentication.
• Jon tells the story about how Mat Honan’s account was hacked.
• The guys talk about how Google Two Factor Auth works for them.
• Jon saw an interesting tip: use a separate e-mail account for password recovery.
• Everyone complains about two factor auth’s usability and hopes it gets easier.
• K. Scott talks about how Internet Explorer 10 will have Do Not Track on by default. The guys talk about their thoughts on targeted ads and tracking: a little is good, too much gets creepy.
• Jon’s using Windows 8 RTM.
• The guys discuss the user interface and discoverability. Scott K worries that nobody will be able to shut their computers off.
• Jon likes the fast install and lock screen. Scott K talks about problems with face recognition login, but it looks like that was removed before RTM.
• OSX Mountain Lion
• Jon asks what the guys think about the change OSX so that Save As also saves over the original file. Kevin talks about some of the things he like in Mountain Lion.
• Jon and Kevin discuss the different ways the Windows and Mac communities react to changes.
• Jon asks about AirPlay and complains that it’s difficult to stream audio from one device to another.
• Kevin talks about the notification system.
• Jon asks about updates to connectors.
• Gold Medal or Martian Hover Crane?
• Unanimous love for the hover crane
• This reminds the guys of a few more books: The Structure of Scientific Revolutions and Physics of the Future: How Science Will Shape Human Destiny and Our Daily Lives by the Year 2100

Show Links:

•  http://bookworm.oreilly.com/
• Books
• The Door into Summer
• The Code Book: The Science of Secrecy from Ancient Egypt to Quantum Cryptography
• The Hobbit: 75th Anniversary Edition
• The Geeks Shall Inherit the Earth: Popularity, Quirk Theory, and Why Outsiders Thrive After High School
• Snow Crash
• Ender’s Game
• Reamde: A Novel
• Cryptonomicon
• The Structure of Scientific Revolutions 
• Physics of the Future: How Science Will Shape Human Destiny and Our Daily Lives by the Year 2100
• Mat Honan’s post: Yes, I was hacked. Hard.
• Matt Cutts: Please turn on two-factor authentication
• IE 10 Do Not Track post: Microsoft to advertisers: Drop dead
• How I became Amazon’s pitchman for a 55-gallon drum of personal lubricant on Facebook
• OS X Mountain Lion: Data Loss via ‘Save As’

Download / Listen:

Herding Code 148 – Chris Hardy on Xamarin, MonoTouch and Mono For Android

Show Notes:

• Jon asks Chris what he does at Xamarin.
• Jon asks about how the development experience works when building an application using Xamarin products and targeting multiple platforms (e.g. iOS and Android)
• Chris talks about how developers create the user interface layers – either using XCode, or just building the UI in code. He mentions PaintCode as a generator for user interface code.
• K. Scott asks about the process of sharing logic and service code between platforms.
• K. Scott asks how iOS and Android can call back into Mono code.
• Jon asks about the installation experience for setting up all of the Android development dependencies.
• Chris mentions that MonoDevelop supports Android UI design.
• K. Scott asks about interesting things people have built with Xamarin. Chris mentions rdio and iCircuit.
• Jon asks how developers handle platform specific issues while developing. Chris mentions several options for sharing code between platforms.
• Jon asks how things are working under the hood – is IL being deployed? Is anything being JITted?
• Jon asks about his opinion as a developer who works on all the main mobile platforms. Chris says he loves his iOS devices, but is interested in Windows 8.
• Jon asks about Chris’ thoughts on the publishing process between platforms.
• Jon asks about the debugging experience – are you using emulators? How do they work? Do you get realtime debugging?

Show Links:

• Chris Hardy (blog, @ChrisNTR)
• Xamarin
• MonoTouch
• Mono For Android
• PaintCode 
• Portable Class Libraries in .NET

Download / Listen:

Herding Code 147 – Jakob Bradford on Organizing NDC Oslo

Show Notes:

• Jon asks how NDC got started and how it’s grown.
• K. Scott says that other conferences feel like they’re organized to solve organizers’ problems, while NDC is organized around the attendee experience. Jakob says that’s very intentional.
• Jon asks how they balance a big conference feel (as NDC continues to grow) while maintaining a personal feel.
• K. Scott asks for an inside scoop – what were the biggest disasters, or almost disasters? Answer: volcanoes!
• Jon talks about how much he likes the Overflow (a.k.a. ADD room) and asks how that got started. Jakob said that’s how conferences are done in Norway.
• K. Scott asks about Aral’s keynote, which began with a musical number.
• Jon asks about how they select speakers and content.
• Jon asks about the pre-conference workshops (in the tallest building in Norway!)
• The entire conference is recorded, available on Vimeo. Jakob says that’s how they get most of their attendees – "Watch the videos a couple years… you will come!"

Show Links:

• Jakob Bradford @jakbradf
• NDC Oslo
• ProgramUtvikling
• NDC Oslo sessions on Vimeo
• Photosynth showing the NDC Overflow Room
• K. Scott Allen’s NDC sessions
• Jon Galloway’s NDC sessions

The NDC Overflow room:

Download / Listen:

Herding Code 146 – Shay Friedman on Roslyn, IronRuby, and the DLR

Show Notes:

• K. Scott asks Shay about the what he covered in his "What? C# Could Do That?" talk. Shay mentions dynamic capabilities, the DLR, and Roslyn.
• K. Scott asks Shay to explain Roslyn. Shay explains how Roslyn works as a very configurable compiler and talks about how his demonstration showed creating a new language keyword.
• Jon asks if it’s possible to build out significant parts of a language with Roslyn. Shay says you’d really use it to extend C# – but there’s more to it than that. He talks about CSX (scripting with C#), C# REPL, and changes to the IDE experience that are now available due to having a much better compiler.
• K. Scott asks if it’s shipping in Visual Studio 2012. Shay says that it’s a CTP, but it’s avialable for both Visual Studio 2010 and 2012.
• Jon asks for Shay to talk more about metaprogramming. Shay explains more about what could be done with this – for instance, an ORM could could add in specialized language support.
• K. Scott asks about the state of IronRuby. Shay says that it’s still active, it’s ignored by the Ruby community, but it has a lot of great applications – for instance, allowing users to write simple business rules in Ruby, and loading Ruby Gems in .NET applications.
• Jon asks if Shay uses the DLR separately from IronRuby and IronPython. Shay mentions some examples like IronJS, Scheme, LUA and LOLCODE. The DLR is built into .NET framework, so it’s not going anywhere.
• Jon asks about how dynamic objects function differently than other C# objects. Shay explains it’s basically an object, but it’s all executed at runtime.

Show Links:

• Shay Friedman blog @ironshay
• NDC 2012 "What? C# Could Do That???" – video
• NDC 2012 "Roslyn hmmmmm WHAT?" – video 
• Sample code from Shay’s talk
• Roslyn on MSDN
• IronRuby
• IronJS
• LOLCODE

Download / Listen:

Herding Code 145 – NDC Cage Match with Rob Conery (node.js/socket.io) and Damian Edwards (SignalR)

Show Notes:

• Jon asks Damian how he’d summarize the distinguishing features. Damian says they’re very similar feature-wise, and it comes down to how you want to develop. Rob says the main difference for him is that node+socket.io is all Javascript, which has pros and cons.
• Jon recalls a part in the cage match where Rob talked about invoking Javascript methods on the client and asks Damian if SignalR can do something similar. Damian talks about how SignalR’s hubs can also invoke dynamic client methods.
• Jon asks Rob about WebSocket support and fallback to older alternatives. Rob and Damian both discuss the fallback methods.
• Rob asks Damian about confirmation and callback support in SignalR. Damian explains how that works with jQuery promises in the Javascript client. Rob asks for more info about how SignalR pushes content to the client, and Damian talks about the use of JSON.
• Jon asks about the differences in development stacks.
• K. Scott asks about what was actually built during the presentation. Rob and Damian talk about what they built in the time available. Rob was wanting to use Backbone if time permitted. Damian says he generally uses simple HTML for many cases.
• Damian calls out a future feature they’re working on for SignalR that adds something like an Update Panel for Web Forms using SignalR.
• Rob talks about the synchronization feature Backbone uses with SignalR and tells Damian they should add something similar to
• Jon asks if Rob and Damian are "web scale." Rob talks about how he load tested using NodeLoad. Damian talks about how he tested using Flywheel and WCAT. Damian says they’ve been able to get great throughput out of SignalR and how they’re moving to some custom data structures to possibly double or triple capacity in SignalR 0.6.
• Rob thinks it’s interesting the SignalR can run outside of ASP.NET, and Damian talks about the hosting models for SignalR.
• Jon asks about some of the differences in development. Rob talks about the Node module ecosystem, Damian calls out some of the advantages of using .NET on the server.
• SignalR runs on Mono.
• K. Scott asks what the future holds for SignalR. Damian talks about 0.6, calling out future performance enhancements in the in-memory message store and standardizing on OWIN as the hosting layer. In version 1, they’re looking at the client story, low level transport, cross-domain support, and more.

Show Links:

• Rob Conery blog Twitter
• Damian Edwards blog Twitter
• NDC 2012 Cage Match – video
• Node.js
• socket.io
• SignalR
• jQuery promise interface
• flywheel
• nodeload
• Web Capacity Analysis Tool (WCat)
• Scott Hanselman’s Million Monkeys in SignalR
• Open Web Interface for .NET (OWIN)

Download / Listen:

Herding Code 144 – GitHub for Windows with Tim Clem, Paul Betts and Phil Haack

Show Notes:

• The guys start off talking about why there is a need for GitHub for Windows.
• Kevin asks if GitHub for Windows can be used as a client for other Git hosts.
• Kevin asks for an overview of GitHub for Windows and if it is similar to GitHub for Mac.
• Jon asks what they did to make the install process so smooth.
• K. Scott asks what technologies were used to build it.
• Scott asks about the features that GitHub has that are missing from GitHub for Windows.
• The guys discuss the decision to use WPF, which leads into a discussion about developer and designer interaction.
• The guys talk about Metro UI.
• Jon asks about the install and update process.
• Kevin asks Phil about his transition from web development to desktop development.
• Jon asks about the different OSS libraries and frameworks used to build it.
• Kevin asks about unit and integration testing.
• Kevin asks if they dogfooded GitHub for Windows.
• The guys talk about line endings.
• Kevin asks about Linus Torvalds’ recent comments about GitHub.

Show Links:

• Phil Haack blog Twitter
• Paul Betts blog Twitter
• Tim Clem blog Twitter
• GitHub for Windows
• msysgit
• GitPad
• GitHub for Mac
• posh-git
• libgit2
• libgit2sharp
• ReactiveUI
• Reactive Extensions
• Akavache
• Cameron McEfee
• NSync
• Caliburn.Micro
• Cef Sharp
• Nustache
• Linus Torvalds comments about GitHub Pull Requests

  Show notes by @rossfuhrman – thanks!

Download / Listen:

Herding Code 143 – Paul Stack on Continuous Delivery

• K. Scott asks Paul for a description of what Continuous Delivery is.
• Paul talks about the differences between Continuous Testing, Continuous Integration, Continuous Delivery and Continuous Deployment.
• Scott brings up the difficulties that databases bring about as it relates to deployments.
• Paul talks about how a distributed cache layer has helped alleviate those deployment problems for him.
• Jon asks how these processes lead software to have a better architecture.
• K. Scott asks how source control plays into the process.
• Paul talks about feature switching, which can be used to turn features on and off.
• Paul talks about the benefits of rapid feedback.
• There is a question from Twitter about databases and data warehousing and PowerShell equivalents of Chef and Puppet.
• Another question from related to the processes related to deploying with TFS.
• Scott talks about his experience prototyping Octopus Deploy.
• Kevin brings up the topic of rollbacks.
• Paul talks about A/B testing and canary testing.
• K. Scott asks about pushback on Continuous Delivery.
• Jon asks if it is possible to incrementally work towards Continuous Delivery.
• K. Scott asks about the pitfalls of Continuous Delivery.
• Jon asks if there are teams or situations that Continuous Delivery would not work.
• K. Scott asks about benchmarking of deployments.
• Another question from twitter related to Continuous Deployment of desktop software.
• Paul gives examples of technology making Continuous Delivery easier.
• Kevin asks if decisions made at the beginning of a project make it harder to implement Continuous Delivery.

Show Links:

• Paul Stack blog
• @stack72 
• SQL Compare
• Team City
• Feature switch library – NFeature
• Flickr feature toggles
• Chef
• Puppet
• Octopus deploy

Show notes by @rossfuhrman – thanks!

Download / Listen:

Herding Code 142 – Scott Guthrie on the ASP.NET MVC, Web API, and Razor Open Source Announcement

Show Notes:

• K Scott asks Scott Guthrie about the recent open source announcements about ASP.NET MVC, Web API, and Razor. Scott G. details what’s changed, highlighting both the new transparency due to working in public repositories and the changes to accept external code submissions.
• Scott G. explains that these are still supported products with dedicated Microsoft engineering investment.
• K Scott mentions a question from twitter – How far will this go? Will we see other products and projects following a similar model?
• Some more questions from twitter – What kind of feedback is Scott G. hoping to see? How will feedback be handled?
• Scott G. talks about how pull requests will be implemented. Developers will have to fill out a form and after they’re on record pulls will reviewed for various factors and then be integrated.
• Scott K. asks a about ownership of the code contributed to the project. Is OuterCurve involved?
• Jon asks a question from twitter: Was this the goal from the beginning? What was the biggest hurdle – legal or logistics. Scott G. mentions the community response to including jQuery in the ASP.NET MVC Project Template.
• Kevin asks Scott about patch contributing that has some performance issues and is the patch rejected or are the issues fixed. Scott G. thinks that minor issues in code might still be accepted or just asked to be fixed. A patch that does noting but "Format C Drive" will be rejected outright, other than that the process is pretty flexible.
• ASP.NET MVC 4 is not taking new features on as it’s currently in a Release Candidate mode.
• K Scott asks how Microsoft chose git as it’s source control. Microsoft sure has made a lot of OSS developers happy using git.
• Kevin points out that the Windows Azure SDK’s are on GitHub and asks why the ASP.NET components weren’t put there as well. Are there plans to move those projects from GitHub to CodePlex now? Scott G. says that CodePlex didn’t support git when the Azure SDK’s were released. With the announcement of git on CodePlex they’ve made decisions based on where they fit best, and ASP.NET content had historically been on CodePlex. There aren’t any plans to move from one to the other, and the beauty of DVCS is that they can be worked on in either place..
• Scott K. talks about how the team received feedback from blogs and mailing lists and now CodePlex discussions and asks about whether feature/roadmap discussions will be public or not.
• Jon asks about how release versions vs. nightly code builds will be supported from Microsoft. Scott G. explains that support will still attempt to help, but of course a released version is recommended for production scenarios.  He also reminds that product support will help with any .NET support scenario, including ASP.NET open source code.
• Jon asked a about how this will affect the Mono project, and Scott G. hopes that it does.
• Scott K. asks about how the release schedule might change now that the projects are open source.
• Scott G. talks about how, by going open source, customer feedback can be potentially received in real time which hopefully increases product quality.
• Kevin asks about community contributions of major new features. Scott G. says it’ll be a learning process, but they’re hoping to see some great ideas from the community. He discusses how Microsoft’s been incorporating open source libraries for a while, including JSON.NET, jQuery, Modernizr, etc., so now there’s flexibility to incorporate features both as core code and as external libraries.
• K Scott says Microsoft has been doing a great job incorporating community projects into their products rather than reinventing the wheel each time.
• Scott K. asks how Microsoft decides to create new projects or use existing solutions from the OSS community. Scott G. says it’s important to keep the MVC core concepts simple while allowing for advanced scenarios, and he and Scott K. discuss the balance between keeping concept count and clutter low while including support for popular scenarios.
• Scott G. mentions that he hopes the new open source view gets Microsoft feedback sooner so that changes can be made faster to final releases which will translate to better products.
• K Scott asks about what’s new in the world of Windows Azure. Scott G. clarifies that his new role includes ASP.NET and the web stack as well, and says there’s a lot of exciting stuff in the works for Azure. Scott G. says he’d like to come back on Herding Code to talk about it when it’s released.

Show Links:

• Scott Guthrie – @scottgu
• Scott’s blog post: ASP.NET MVC, Web API, Razor and Open Source

Show notes by @buildstarted – thanks!

Download / Listen:

Herding Code 140 – Lightning Round with Hadi Hariri

Show Notes:

• K Scott asks Hadi about EasyHttp.
• Hadi explains some of the problems and annoyances EasyHttp solves.
• Configuring the web request was a pain
• It was annoying to change the data structure of the classes to work with dynamic JSON
• EasyHttp supports all HTTP verbs (including PATCH and OPTIONS)
• It works really smoothly with dynamics
• Hadi talks about a library he used called JsonFx, which he prefers to JSON.NET
• Hadi says he decided to build out EasyHttp due to his work on YouTrackSharp
• That’s it! Scott runs off to tackle some more lightning round interviews.
• K Scott asks about EasyMVC
• Hadi talks why he created EasyMVC, explaining how the convention based routing works.
• EasyMVC also includes some filters which use conventions to handle content negotiation.
• K Scott asks what Hadi thinks about ASP.NET Web API. Hadi says he dislikes it, as it pushes developers towards having separate controllers for HTML and services.
• K Scott wraps up by asking Hadi about Kotlin.
• Kotlin is a new language in the JetBrains early access program.
• Kotlin attempts to improve on some of the shortcoming that JetBrains has seen working with Java.
• Kotlin is perhaps conceptually similar to Scala, but a lot easy to learn
• Object oriented with nullable types.
• Kotlin targets both the JVM and JavaScript
• It’s open source, and in early alpha phase.
• That’s it! Hope you liked K Scott’s lightning round interviews!

Show Links:

• Hadi Hariri – @hhariri
• EasyHttp project
• JsonFx project
• YouTrackSharp project
• EasyMVC project
• Blog post: With HTTP, your application is your API
• Blog post: The Kotlin Journey Part I : Getting things set up
• Kotlin project

Download / Listen:

Herding Code 140 – Lightning Round with Morten Kromberg

Show Notes:

• Morten describes the history and purpose of APL.
  • Did you know that APL stands for "A Programming Language"?
  • The first book about APL was written in 1962. It’s as old as COBOL and FORTRAN.
  • APL was first written as a mathematical notation, and was used in teaching for 4 years before an interpreter was even written.
• It’s a dynamic, interpreted language, and it encourages a functional style. Dyalog APL, which branched off about 30 years ago, is even more functional.
• People are still developing with APL, especially within the financial sector.
• Morten’s company makes APL interpreters.
• K Scott asks about the ability to work with APL from .NET. Morten says that, while it’s not a managed language, they have full interop so you can both create .NET classes in APL and consume them. You can use the GUI features in Dyalog APL, or you can interop with Windows / .NET GUI’s, and it can even be used as an ASP.NET scripting language.
• K Scott asks why such an interesting language that’s been around for so long isn’t well known. Morten speculates on some reasons and talks about why he thinks it’s seeing a resurgence.
• Morten and K Scott talk about some of the examples which really show off the language, such as a one line implementation of Conway’s Game Of Life.
• Morten talks about how APL sees matrices as a fundamental concept, expressing them at a level higher than objects.
• APL is a very agile language, as it encourages direct interaction from domain experts.
• Morten recommends http://tryapl.org, an interactive website where you can learn more about APL.
• That’s it! Scott runs off to tackle some more lightning round interviews.

Show Links:

• Morten Kromberg – @mkromberg
• Dyalog APL
• APL on Wikipedia
• Conway’s (very concise) Life
• TryAPL

Download / Listen:

Herding Code 139 – Lightning Round with Roy Osherove

Show Notes:

• K Scott asks Roy about his new book.
• Roy talks about the LeanPub approach.
• Roy describes the two parts of the book – elastic leadership and community contributions featuring notes from team leaders.
• K Scott says that our industry often throws developers into leadership positions, and the transition can be difficult. Roy agrees, and says these are the notes he’d wished he had when he was a new leader. Back then he thought he was doing a good job, and was having fun, but wasn’t really doing his job.
• Roy talks about how he got started, explaining how his passion is at the crossroads of where people and software meet. This book is coming out because it needs to come out – it’s a missing book.
• Different team phases require different leadership types, describing his elastic leadership approach that deals with the three phases he’s observed:
  • Chaos phase
  • Learning phase
  • Self organizing team
• What are some common mistakes?
  • Not recognizing which phase your team is in
  • Being afraid of talking to people about difficult things
  • Not understanding how to influence behavior
• That’s it! Scott runs off to tackle some more lightning round interviews.

Show Links:

• Roy Osherove – @royosherove
• 5whys blog
• http://leanpub.com/teamleader

Download / Listen:

Herding Code 138 – Douglas Crockford

Show Notes:

• K Scott asks Douglas what he meant when he said that the human brain wasn’t designed for this sort of work? What were we designed for? Douglas talks about how our minds are selected for hunting and gathering, but we have to work with what we’ve got, relating this to some tips for defensive programming.
• K Scott asks about JSLint. Douglas talks about how he thinks all languages should have code quality tools.
• The increment operator came over from C++ due to pointer operations. Bad idea?
• K Scott asks where he sees JavaScript going. Are things moving too fast, or too slow? Douglas talks about the difficulty of supporting multiple browsers and versions. EcmaScript 5didn’t break things, but EcmaScript 6 is making some bets to allow for that.
• EcmaScript 5 introduced "use strict" – how does that work? Douglas talks about the use of useless expressions.
• K Scott asks what developers should be doing today. Douglas says developers should be working in the intersection of EcmaScript 3 and the strict parts of EcmaScript 5 to be ready for EcmaScript 6.
• That’s it! Scott runs off to tackle some more lightning round interviews.

Show Links:

• Douglas Crockford
• JavaScript, The Good Parts
• JSLint
• EcmaScript 5
• Strict Mode Is Coming To Town (YUI Blog post by Douglas Crockford)
• ECMAScript 5: The New Parts

Download / Listen:

Herding Code 137: Mass Assignment, New New iPad, JavaScript libraries, Windows 8, Visual Studio, and Sad Trombones

Show Notes:

• K Scott asks everyone’s opinions on the GitHub / Ruby on Rails “mass assignment” debacle.
  • Everyone talks about mass assignment binding issues in MVC frameworks, including Rails and ASP.NET MVC – is this a security issue in the frameworks, or the web developer’s responsibility?
  • Jon says that it’s often tricky to debug negative cases, Kevin says that everything should be secure by default, and Scott K can go either way on it.
• K Scott asks us all who will buy the new new iPad.
  • Scott K says it struck him that they were limited in demonstrating it by the projection resolution.
  • Kevin wants one.
  • Jon thought it was interesting that Retina isn’t a hard DPI spec, it’s driven by the expected distance the device will be from your eyes – can he get a Retina effect by just sitting far from his desktop monitors?
  • There’s a discussion about the lack of a version number.
  • Jon wonders if that high quality of display will show up on other devices, or if Apple bought all the pixels. Oh, and patents.
  • K Scott asks Kevin if Samsung users laugh at him.
  • Jon says that’s no longer a issue now that software updates brought 4G to this iPhone… magic!
• Twitter question: What JavaScript libraries is everyone using?
  • Kevin talks about the Mocha JavaScript test framework.
  • Jon mentions Upshot from the ASP.NET Single Page Application framework.
  • K Scott talks about Sylvester and Zoomooz.
  • Scott K talks about tiny libraries like Zepto, Ender, and the Micro.js list.
  • Jon says he likes cdnjs.com for JavaScript library hosting.
• Scott K talks about the difficulty he had in shutting down Windows 8.
  • Jon says it’s all about search now… and what’s wrong with hitting the start button to power off?
  • Scott K says we’ve been trained for decades not to do that.
  • Jon says this is the biggest shift since Windows 95… there’s a lot of learning and unlearning to do.
• What about Visual Studio 11?
  • There’s some discussion about the color and design aspects. Should there be color? Metro?
  • Jon says at least it’s a lot faster, and he likes the quick search.
  • Scott K said it worked fine once he figured out what it was for… and maybe there should be fewer items in the menu to begin with.
  • Jon throws out a crazy idea – what about the ribbon interface for Visual Studio and kind of convinces Kevin.
  • Scott K says the memory usage is still way too high. Jon asks if that really matters. After some discussion, Scott K says something’s slow in there.
  • Oh, hey, the macro recorder’s gone now. Jon actually used that in Visual Studio recently.
  • Kevin asks if there’s really no way to customize the install anymore. The gang all agree they don’t want to install stuff like C++ and VSTO. Jon says the blog post says that few people actually customize the installation, but Scott K doesn’t believe it.
  • Scott K runs through some fun issues on the Visual Studio UserVoice.
  • Kevin put up a bajillion issues on Connect long ago, most are Closed – Won’t Fix.
• Jon talks about a post about 24 bit / 192 khz audio he read. Nobody seems to care all that much.
• Jon asks everyone what they’ve been up to.
  • K Scott’s travelling around and working on project that’s Ruby / Mongo on the backend and ASP.NET MVC on the front end. This freaks Kevin out.
  • Jon’s been working on ASP.NET MVC / Web API release stuff and hacking on Code52 project late at night.
  • Scott K spoke recently at NodePDX on is doing a bunch of crazy stuff at work around deployment.
  • Kevin remembers what a DSN is when nobody else does.
• Somebody sneaks in a Sad Trombone. Jon is unable to figure out who is playing tricks and motions to adjourn.

Show Links:

• GitHub posts: Public Key Security Vulnerability and Mitigation and Responsible Disclosure Policy
• Brad Wilson post: Input Validation vs. Model Validation in ASP.NET MVC
• Mocha – JavaScript test framework
• Sylvester – Vector and Matrix math for JavaScript
• Zoomooz – an easy-to-use jQuery plugin for making any web page element zoom
• Zepto – a minimalist JavaScript framework for modern web browsers*, with a jQuery-compatible syntax
• Ender – The no-library library
• microjs – tiny JavaScript libraries
• cdnjs.com – The missing CDN (for all the other JavaScript libraries)
• Windows 8 blog post – Evolving the Start menu
• Visual Studio 11 Beta Performance blog post series
• Visual Studio UserVoice
• Kevin Dente’s Visual Studio Connect Bug list
• 24/192 Music Downloads …and why they make no sense
• Scott K’s talk at NodePDX – info / video

Download / Listen:

Herding Code 136: Code52 with Paul Jenkins, Brendan Forster, and Andrew Tobin

Show Notes:

• Jon starts by asking how this whole idea got started.
• Brendan explains the timeline of a one week spin up cycle for a project.
• Jon asks if the projects just die at the end of a week, and if people are continuing to work on past projects. Paul and Andrew talk about the continuing work on all projects, including MarkPad .
• Jon says he thinks the concern of abandoned open source projects is overblown – collaboration is good, working
• Jon asks about the projects they’ve done so far, and the guys run through the list.
• Brendan explains how the different projects are selected.
• Jon asks about how technologies are selected. Brendan says that it’s all based on who shows up, and Andrew mentions the wide variety of technologies that have been covered so far.
• Paul says that the "bite sized projects" have been a good way for developers who are new to open source to get started. Jon asks how new developers can get ramped up, and Brendan lists some of the onboarding resources. Andrew explains that it’s hard to write much documentation when the projects are running for a week. Andrew mentions some of the Git documentation they’ve got written up.
• Scott K says he’s got a ton of personal projects that he doesn’t have time for. Everyone talks about the benefit of getting a team on a project for a week.
• Jon asks about some of the common frameworks that they use over and over. Paul talks about MahApps.
• Scott K asks about non-CLR project, like some crazy project in obscure languages. Brendan says the main focus is on building something useful in a week, which usually leads towards common languages. Brendan says that projects in other languages really need a "champion" to show up and lead the project for a week – and the door’s open.
• Jon asks about the community reaction overall. The guys talk about the wide attention, as well as some negative reactions from onlookers who want to see other technologies represented.
• Jon says he thinks there was some pent up need for energy in the .NET open source space, and asks if that was part of the reason for getting this started.
• Jon asks Paul about the "Mah" name he’s used for his open source projects.
• There’s a discussion of developing while hungry, including the Pretzel project name and the "Jon should make me a delicious cake" incident.
• Andrew talks about the GTFO project – GitHub Tools For Outlook
• Jon asks about the .NET developer community in Australia. Is it  as huge as it seems?
• Question from Twitter – @wolfbyte asks: "How do you balance the shifting of tools / ideas / processes against the goal of attracting people to open source development.
• Another question from @wolfbyte: "Are you guys tired yet?" (Yes!)
• Jon asks if there’s thought as to how to scale things going forward to all the work doesn’t fall on Paul/Brendan/Andrew for all projects. Is there a possibility to bring in guest leads for a week?
• There’s a discussion of HattersGonnaHat and the Konami code. Jon announces a new KDD movement: Konami Driven Development.
• Some discussion of Windows 8 development (update: the 3/5 – 3/12 project is Windows 8).
• Would it be possible to do more cross-platform work? Silverlight?
• What will the future projects be? Jon campaigns (in vain) for his Diff/Merge 2000 project proposal.
• Jon asks for more information about how they run all the behind-the-scenes communications and infrastructure. GitHub, App Harbor, JabbR – all are low friction and low / no cost.
• Jon asks about the amount of work involved in accepting pull requests.
• Brendan talks about the test coverage in code submissions. Paul says that having testing frameworks in place makes it a lot more likely that people will write the tests.
• Brendan wraps with a call to look at Code52.org and get started. Jon pledges to fly to Australia in luggage class, then offends everyone by confusing Australia with New Zealand.

Show Links:

• Code52 site (@code_52)
• Code52 JabbR room
• Andrew Tobin – blog, twitter
• Brendan Forster – blog, twitter
• Paul Jenkins – blog, twitter
• Code52 projects to date:
• MarkPad – A Markdown editor for
• jibbr – A Jabbr bot designed for collaborative
• Ideastrike – A collaborative idea voting site
• Samurai – A tiled, turn-based player-vs-plaryer game with an MVC 4 backend and the beginning of Windows Phone and iOS front ends
• Pretzel – A static site generator with Markdown and Liquid (and Razor on the way)
• metro.css – A CSS bootstrap package to simplify building web applications with a Metro look
• Carnac – A utility that displays keyboard shortcuts as you type them
• GT4O – An addin for managing Github tasks inside Outlook.
• i18n Packages for MVC4 – NuGet packages to simplify internationalization in ASP.NET MVC applications
• MyFinances for Windows 8 – A Javascript-based application for WinRT
• GitHub post – A New Coding Project Every Week at Code52
• #HattersGonnaHat
• Konami code
• MahTweets
• MahApps

Download / Listen:

Herding Code 135: Remco Mulder and Jeff Schumacher on Continuous Testing

Show Notes:

• Scott K kicks things off with a horrible old school BASIC joke.
• Remco explains how NCrunch got started because he was living under a rock.
• Jeff explains how Giles got started by finding AutoTest and seeing it not maintained (in reality it was).
• Remco talks about the number of test frameworks.
• Jon asks Remco about adding MSTest support – Remco groans about how difficult MSTest was to integrate with NCrunch.
• Jeff mentions that xUnit’s test runner is complete for backward compatibility.
• Jeff talks about Machine Specs and avoiding versioning hell with Impromptu Interface.
• Jon asks about each library’s approach to Continuous Testing and to explain it to a laymen.
• Rem explains what Continuous Testing is in relation to NCrunch.
• Scott comments on a "strange situation" of testing compiled code creates slow tests and asks about any shortcuts Rem or Jeff have taken.
• Jon comments how NCruch & Giles gives immediate feedback as he’s coding.
• Jeff mentions that Giles has the ability to filter tests so that you only see what you want to see.
• Remco explains how NCrunch attempts to determine impact to order how tests are run so the most pertinent tests run first.
• Jon gives his quick history of the testing feedback cycle: separate project phase, then repository check-in step with continuous integration, local test runers, and now tests running as we write the code. Are we done? Where can we go from here?
• Jeff comments about how Continuous Testing is like the red squiggly for code problems.
• Scott asks about alternative language support for NCrunch and Giles.
• Remco mentions that Salesforce.com has a Selenium "cluster" to continuously run UI tests.
• Remco talks about Visual Studio integration for NCrunch.
• Jeff talks about a branch that supports Mono.
• Jon talks about Roslyn, and Scott K reminds us that Mono was doing compiler as a service long ago – 2008?
• Remco jokes about clippy.
• Jeff talks about Continuous testing and Pair Programming.
• Jeff wanted to get to the point where he didn’t think about the tooling but only the tests and the code.
• Jeff talks about Visual Studio magazine and an article about Continuous Testing.
• Jon comments how easy NCrunch is able to setup and get going.
• Remco wants to make Continuous testing really really easy to get people to start using it.
• Jeff recommends looking at all the different continuous testing options, mentioning Greg Young’s Mighty Moose.

Show Links:

• Jeff Schumacher – blog, twitter
• Remco Mulder – blog, twitter
• NCrunch
• Giles
• Mighty Moose from Greg Young
• Continuous Testing: Think Different [Visual Studio Magazine online]
• Project Roslyn

Show notes by Ben Dornis. Thanks!

Download / Listen:

Herding Code 134: Brad Wilson on ASP.NET 4 Beta and ASP.NET Web API

Show Notes:

• Brad starts with a rundown of what was in ASP.NET MVC 4 Developer Preview, including HTML5 Default Template features, Adaptive Rendering, Mobile Template, Display Modes, NuGet package based installation, and Task<T> based Async Controllers.
• Jon asks about the ASP.NET Web API integration. Brad talks about the effort involved and why it’s useful.
• Jon asks for clarification as to what ASP.NET Web API offers over hand writing services using ASP.NET MVC.
• Brad talks about Content Negotiation and why it’s useful.
• Jon asks about things that Web API has in common with MVC like filters and model binding.
• Jon asks about the testability of Web API. Brad explains that it’s much more lightweight and has a lot less use of statics, making it a lot more testable.
• Brad talks about the hosting models for Web API, including both web and selfhost. He explains that it’s pluggable, so you can write your own host, and explains the use of HTTP Message Handlers.
• Jon asks about the relation of ASP.NET MVC 4 to .NET 4.5. Brad explains how parts were backported to allow for using .NET 4.5 features on .NET 4.
• Jon asks about the query composition support, which gives support for OData query syntax. Brad explains how it’s used, and distinguishes the query syntax from the rest of OData format.
• Brad explains how ASP.NET Web API is the future of WCF Web API, and that the ASP.NET team and WCF teams have merged.
• Brad talks about how Web API can be used outside of ASP.NET. Jon asks how to get Web API into another project type, and Brad talks about installing Web API via NuGet.
• Jon asks for more information about how NuGet is used in the MVC installation system. Brad talks about how NuGet and VSIX can be integrated.
• Jon asks about why NuGet Package Restore is useful.
• Jon notes that creating new projects is slower due to NuGet installation. Brad says this may be improved, but even if it isn’t he thinks that the tradeoff is more than worthwhile, since in the real world people aren’t creating new projects every day.
• Jon asks for a bit more information about the Display Mode Provider.
• Brad talks about the installation options for ASP.NET MVC 4 Beta and how it relates to the .NET 4.5 developer previews.
• Jon asks about Go Live license, Brad says it’s there.
• Jon asks about new features in xUnit.net. Brad talks about the last release and what’s in the roadmap for the next release.
• Brad mentions that he’ll be speaking at NDC this summer and talks about the Wrox MVC 4 book.

Show Links:

• Brad Wilson – blog, twitter
• ASP.NET MVC 4 Beta info
• xUnit.net
• Henrik’s blog

Download / Listen:

Herding Code 133: Derick Bailey on Backbone.js

Show Notes:

• Derick starts off by explaining what Backbone is not: a JavaScript MVC framework.
• Backbone provides a way to structure and organize your code, separating responsibilities in to easily recognizable pieces.
• Derick points out that Jeremy Ashkenas, the creator of Backbone, said that Backbone is a library. The distinction Derick references is: "a framework calls your code, you call a library’s code."
• Kevin asks what are the main parts of Backbone. Derick mentions models and collections, views, routers, and some helpers: backbone.sync, backbone.events, and history.
• Kevin asks for a clarification on what a single-page application is. Derick cites Gmail as the canonical example.
• Kevin asks if Backbone is mainly used for single-page applications. Derick explains that it is very flexible and can be used as much or as little as necessary for any kind of application.
• Jon asks if using Backbone is an all or nothing proposition or if bits and pieces can be brought in over time.
• Kevin asks for a comparison to other similar JavaScript libraries/frameworks.
• Jon asks if there are any template or boiler plate projects for getting started with Backbone.
• K. Scott asks about Derick’s Memento plugin, which allows you to store and restore your model’s state.
• Kevin asks Derick why he thinks Backbone has become so popular.
• Jon asks about the process and requirements for creating Backbone plugins.
• Jon asks about the debugging story when using Backbone.
• Kevin asks about tools and approaches for testing Backbone.
• Kevin asks if there are any sources for best practices for Backbone.
• Twitter questions from @elijahmanor: "In what type of applications would you not recommend using Backbone?", "Do you plan to consolidate your blog posts into a Backbone book?", "Have you done any mobile development with Backbone?, "Do you use Require.js alongside Backbone?"
• Kevin and Derick discuss server-side rendering of JavaScript with Backbone for the purpose of being easily findable by search engines.
• Derick talks about the on-site training and training videos that he offers.

Show Links:

• Derick Bailey blog
• Twitter
• Backbone
• Jeremy Ashkenas – Founder of Backbone
• Zepto.js
• Backbone.js Is Not An MVC Framework
• SproutCore
• Batman.JS
• Ember.js
• JavaScriptMVC
• Agility.js
• Knockout
• Spine
• CoffeScript
• Knockback
• Dericks Backbone data binding plugin
• Bocoup – Introducing the Backbone Boilerplate
• Backbone mailing list (Google Group)
• Backbone.Marionette
• BBCloneMail on GitHub
• BBCloneMail live on Heroku
• Backbone.Memento
• Underscore.js
• Joey Beninghove
• QUnit
• Jasmine
• jasmine-jquery
• Sinon.js
• Rob Conery refactors the Backbone.js todo list sample
• Derick’s list of Backbone resources
• Require.js
• backbonetraining.net
• watchmecode.net

Download / Listen:

Herding Code 132: Phil Haack, Keith Dahlby and Paul Betts on Git for Windows developers

Show Notes:

• Paul begins with talking about why he thinks Git is cool, starting with the ability to create a clean source history that’s based on intent.
• Phil says some people who aren’t used to distributed version control get the wrong impression of rewriting history. The idea is that you’re rewriting history as you work locally to build a clean commit. You don’t generally rewrite history once you’ve pushed to the master repository.
• Keith says he tells people that when you push, it’s permanent. Until then, you can pretend you’re perfect. It’s just a save point – this reminds Jon of a quote from Dave Ward that this is like the ability to create save points anywhere in a video game.
• Scott K says this is all great in theory, but he never sees people taking advantage of history rewriting. He goes on to say that he loves GitHub but hates Git because Git hates developers – rewriting history is way too hard.
• Phil says that this makes more sense when you think of this in terms of replaying changes.
• Phil says that he really started liking Git after reading the site Think Like (a) Git.
• Paul says that he thinks this would be a lot easier to understand if you could see and work with things visually. Scott K says gitk kind of works but it’s clunky. Keith talks about gitk a bit more.
• Scott K talks about how he regularly ends up with a corrupted state and asks for recommendations. Paul says the solution is to use either git reset or git rebase and explains what they mean. Jon asks for more info, and Paul talks about git reset –hard.
• Phil talks about the importance of following an established workflow to avoid problems or getting in a state you don’t understand. He talks about the published workflow they use for the NuGet Gallery. Paul talks about how he and Phil are working on improving the interface to make it easy to follow working patterns.
• K Scott talks about one confusion is that there are so many commands and parameters. Keith says that you can get by with a tiny subset, and can grow as needed.
• Kevin asks if it’s possible to get your repository into a corrupted state, or if users are just getting confused by a valid state. Paul talks about some finer points of how things are stored and wraps up by saying really the only way to lose work with Git is to mess up or delete uncommitted changes or files.
• Twitter question from @LeeFlannery: "can you discuss how command line git for Win isn’t so scary – stop waiting for integrated VS tooling to use git." Paul talks about how the MSysGit makes things unnecessarily confusing by making you think you need to use the Bash prompt.
• Twitter question from @JavierLozano: "Why use powershell instead of bash for a console client? What are the gains?" Keith explains how posh-git gives you a Windows native experience (e.g. Windows style file paths). Phil talks about how the posh-git tab extensions give you an IntelliSense-ish experience with Git. Keith explains that posh-git does things like keeps track of which file have been added, so you can autocomplete files you’re adding rather than have to type them out.
• Scott K says that posh-git was slow when he tried to use it and asks if performance has been improved. Keith says that posh-git calls git status on every action to offer contextual tab expansions and explains how to disable that for faster performance.
• Keith talks about installing posh-git using psget, and more advanced use by cloning the posh-git repo and customizing it. Jon asks why installing posh-git in command-line didn’t work in the PowerShell ISE, and Keith explains that there are separate profiles for PowerShell command line, PowerShell ISE, and the NuGet Package Manager prompt in Visual Studio.
• Question from John Sheehan: "What are some of the other things outside of tooling that are impediments to Windows users adopting Git." Paul lists several: line endings, SSH keys, the MSysGit install, and the git commit using vi in compatibility mode.
• Keith says that MSysGit isn’t Git for Windows, it’s Git for Linux developers on Windows – it doesn’t behave like Windows at all. Keith asks who runs MSysGit.
• Phil says there are a lot of conceptual obstacles to adoption, and says that he thinks it’s necessary to make it easier to do simple things without worrying about obscure and advanced options.
• Jon talks about the frustrations in typing in the SSH passphrase and asks for suggestions. Paul talks about ssh-agent.
• Jon asks for specifics about what Paul and Phil are working on. Paul say the idea is similar features to GitHub for Mac – not necessarily in design, but featureset.
• Jon says that he likes how the TortoiseHg tooling shows the command-line version you could have typed when you perform operations in the GUI. Paul agrees that’s useful, and Keith points out that it’s available in Git Extensions.
• Scott K says that he likes the built in Mercurial server and says it’d be nice if Git made it easier to run a Git repo on Windows. Paul says that it’s really easy to set that using a fileshare. Scott K says he uses that, but it’s not as discoverable as the Mercurial webserver. Keith talks about how setting up he’s seen this set up using per-user shares.
• Twitter question from @jeremydmiller "Are you concerned that folks spend so much time debating and tweaking their Git workflow that they’ll forget to actually code?" Phil and Keith discuss two popular GitHub workflows: GitHub Flow and git-flow.
• Twitter question from @kppullin "why must line endings be so painful!" Paul explains the source of the problem and how autocrlf tries to solve that, and there’s a general about how problems occur.
• Keith talks about using gitattributes to do things like telling Git to use C# differencing with .cs files.
• Jon asks finding good, non-hostile documentation. Scott K says that all the books focus on happy path documentation rather than useful stuff. Some useful online resources are listed, including Think Like (a) Git, The Git Parable, and ProGit.org.
• Keith jokingly asks if we can talk about why Git is better than Mercurial. Jon takes the bait, and hilarity ensues.
• There’s a long discussion about the usefulness of a clean history and the ability to accurately use "blame" to understand when a bug was introduced.
• Things start to wrap up and K Scott asks for last thoughts. Paul mentions GitPad, which sets Notepad as your Git commit editor. Keith recommends Console2. Phil points out a neat hidden feature on GitHub – using T to get incremental search.

Show Links:

• Phil Haack – @haacked
• Keith Dahlby – @dahlbyk
• Paul Betts – @xpaulbettsx
• GitHub
• Think Like (a) Git
• posh-git
• Phil’s recent post about posh-git: Better Git with PowerShell
• gitk
• GitHub Flow
• git-flow
• Git Extensions
• GitHub for Mac
• The Git Parable
• ProGit.org
• ProGit chapter on gitattributes
• GitPad
• Console2

• Jon asks Chris to catch us up with what’s happened since we last talked to him, just after jsConf.us 2010.
• Chris starts with his jsConf.eu 2010 talk, including Promote.js and the reminder not to forget the roots of the Javascript community.
• Chris doesn’t speak at the jsConf.us conference, mostly because he organizes the US conference and doesn’t want to present an appearance of unfairness.
• Chris then moves on to his jsConf.eu 2011 talk, An End To Negativity.
• Chris says that the negativity is rampant in the programming community, and it feeds on itself. There are far too many people who participate in community conversation just to cheer on the fights. Our profession has a unique opportunity to create and try new things, but the negativity in the community stifles that. We need to stop the negative “hating” in private conversations, not shouting matches in online forums.
• If you disagree with a technology, put your energy to constructive use via open source contribution (fork and create) rather than writing scathing blog posts.
• Scott K says that negative discussion’s everywhere – all online discussion, politics, media. Rather than discuss ideas, people just call others idiots. Chris says you’ve got to start locally. His recommended solution involves beer.
• Matt says it’s easier to lob bombs from afar, and personal discussions solves that. Kevin says one on one discussions over beer aren’t always possible, and Chris says even the offer is what’s important.
• Jon says that he’s never tried to resolve issues one-on-one and come away convinced that the other person is just plain evil. Usually there’s some unspoken history that explains why people think as they do. Chris applies that to prejudices against Javascript that were formed by bad experiences people may have had long ago.
• Jon says he’s noticed that Chris’ speaking style is disarmingly humble. Chris says he really values humility in developers, and that the current rock star ninja terminology is too self promoting.
• Jon says that the online discussion forums like Reddit and Hacker News are all about voting up or down, which encourages negativity. Chris talks about trite these arguments often are, such as focusing on features which aren’t yet implemented in new technologies.
• Scott K. says he’s amazed at the overall positivity on StackOverflow. Chris says he thinks it’s a matter of time before it creeps in. Jon says he thinks that he thinks the vote engineering and overall problem solving focus of StackOverflow is designed to produce overall positive results.
• Jon reacts to Chris’ Fork and Create call by saying that when he’s releasing code publicly, it’s a lot harder to criticize others. Chris says that people who are busy creating don’t have time for trivial arguments, and Matt says that working publicly gives you a healthy dose of vulnerability.
• Chris talks about the negativity he encounters in putting on conferences. At jsConf.us 2011 they raised over $3000 to contribute towards increasing gender diversity and it received no attention at all, while a negative incident at the conference got a lot of attention.
• Jon says that in teaching his daughter some basic programming, he’s reminded of the fun of creation that got him started in development. That’s got to be our focus. Chris and Matt talk about how their parents spent time introducing them to computers, and would love to see parents introducing their kids to computers.
• Scott K says that he’s seen the community as a whole move from a focus on writing code to macho chest thumping.
• Jon says he liked the part of Chris’ keynote that welcomed Dart and CoffeeScript. Chris said that innovation and new languages are great since they move things forward. Chris points out that people bash on Flash, but forget that it was instrumental in the development of Javascript through things like JIT compilation.
• Scott K wonders if we’d do better to just create new languages more often. Jon says that’s tricky with Javascript since it runs on so many platforms, but Scott K says that he thinks there’s more room for extending Javascript inside the language itself. Chris says both can be powerful, and mentions ClojureScript. He says that the velocity of change for Javascript is accelerating with more frequent browser releases and the things he’s seeing in Windows 8. He says we need to embrace that change by being more willing to drop support for older browsers.
• Christ talks about how TeamJS is raising money in the Mozilla Firefox Challenge (please join in!).
• Jon reacts to Chris’ keynote question, “What would you do if you knew you could not fail,” noting that most of his personal failures come from not attempting things. Chris says that quote is inspirational to him, and agrees that we fail in 100% of things we do not attempt.
• Twitter question from @elijahmanor – “Recently Chris tweeted that the trolls may be right. What did he mean by that?” Chris says that a reaction to hype around node.js, and there’s a general discussion about node.js.
• Jon asks Chris about his reactions overall to Microsoft getting involved with things like node.js and Javascript on Windows 8. Chris says that the community sometimes has an initial shock, but Microsoft-of-new is a different company that’s doing a lot of great stuff. He says he’s happy to see talks from Microsoft developers that aren’t “Microsoft presentations.”
• Matt talks about a recent node.js talk focused on maximizing node.js hosting efficiency.
• Jon asks Matt and Chris to give us a heads up on some emerging technologies in JavaScript land. Matt mentions emscripten, jsmad, and RiverTrail.
• Jon asks if people (himself included) will eventually realize that Javascript isn’t inherently too slow for these computationally intense applications. Scott K and Matt talk about how things like V8, JITing, and investment by big companies continue to make Javascript faster and faster.
• Jon asks Chris what trends he’s noticing, and he mentions dynjs, pdfjs, and jslinux. He mentions browser vendors moving towards extension systems based on Javascript. Jon talks about how he thinks Mozilla’s XUL was so far ahead of the game, using HTML/CSS/Javascript as a development platform.
• Matt brings up JSIL (a compiler that transforms .NET applications to Javascript). There’s a discussion of Javascript as a VM for other languages. Matt mentions Microsoft’s Volta initiative.
• Chris and Scott K talk about putting other languages in the browser. Chris says that Javascript has been battle tested in a way that no other language has.
• There’s a discussion of the node.js work that Microsoft’s been doing – not just getting it to run on Windows, but in making Windows / IIS hosting for node.js compelling.
• Jon asks Chris and Matt for their current recommendations, and an argument over spring beers erupts.

Show links:

• jsConf.us, jsConf.eu
• Chris Williams’s Blog, @voodootikigod
• Matt Podwysocki’s Blog
• Promote JS
• bcrypt
• Issue 28
• The Problem with Implicit Scoping in CoffeeScript
• Raganwald: CoffeeScript is not a language worth learning
• ClojureScript
• TeamJS donating to the Mozilla Firefox Challenge
• denser – an experiment with high density server side java script
• Erik Corry – Garbage Collection in JavaScript
• emscripten – an LLVM-to-JavaScript compiler
• jsmad – a Javascript MPEG audio decoder
• RiverTrail – a ParallelArray abstraction for JavaScript
• Atwood’s Law
• dynjs – (almost) 100% invokedynamic js impl
• pdfjs – PDF Renderer in Javascript
• jslinux – Linux shell running in Javascript
• Mozilla XUL
• JSIL
• Microsoft Live Labs Volta

Download / Listen:

Herding Code 131 – Chris Williams and Matthew Podwysocki on the Javascript community

• Dave runs Markkup, a consulting company and is building Loggr, SaaS application that provides real time logging and monitoring.
• He was one of the founders of Chili!Soft, which was an implementation of Classic ASP that ran on Linux, Solaris, IBM software, and Windows.
• Dave tells the story behind Chili!Soft, which is now Sun Java System Active Server Pages.
• Dave goes into the main features/benefits of Loggr.
• Jon asks about reports and queries provided by Loggr.
• Dave mentions there is an HTML5 version of the dashboard that works well on a tablet as well as an iPhone app. There is also an Android app in the works.
• Jon and Dave discuss the freemium model that Loggr employs.
• The guys move to talking about the stack that Loggr is developed on.
• It is built on ASP.NET MVC2.
• It uses Backbone.js for the client side JavaScript.
• MongoDB is used as the database.
• SignalR is used for the client-server communication to provide live user monitoring.
• Kevin asks about the decision to build a startup on the .NET platform.
• The guys touch on the VB.NET vs C# debate.
• Jon asks about the backup/redundancy story for MongoDB.
• Dave talks about the HTML5 client vs the native iOS app vs the Android app.
• Jon asks about the experience developing the iOS and Android apps.
• There are agents for .NET, Java, ColdFusion, PHP, Ruby, JavaScript.
• You can configure log4net to log to Loggr.
• Dave mentions Loggr uses Rapleaf to display demographics for a user, such as age and gender.
• Loggr also uses FullContact to display the social networks and avatars of a user.
• Jon asks Dave for advice for anyone interested in starting a similar venture.
• Jon asks about the Loggr road map.
• Jon asks about the business and marketing side of Loggr.
• Jon asks if any companies are leveraging the Loggr APIs to create other offerings.
• Jon asks if there is any demand for customers to host Loggr internally.
• Kevin asks if there have been any issues related to versions of the Loggr APIs.
• Kevin asks about downtime and SLAs.
• Jon asks about the process to get started with Loggr.

Show links:

• Loggr @loggrnet
• Dave Weaver’s blog @davidweaver
• Markkup
• Joel on Software post about Chili!Soft
• Sun Java System Active Server Pages (formerly Chili!Soft)
• Mission Research
• Blog post referencing Google Analytics
• Irony on CodePlex
• Loggr code on Github
• Backbone.JS
• MongoDB
• Official MongoDB C# driver
• SignalR
• MonoTouch
• Mono for Android
• Nlog writes to Loggr
• log4net
• Rapleaf
• FullContact
• Evernote
• Exceptioneer

Download / Listen:

Herding Code 130: Dave Weaver on Loggr – a realtime analytics service built with MVC MongoDB and SignalR

This week’s show notes were typed up by @RossFuhrman – Thanks!!!

• Rob talks about how Nu helped shape the direction of NuGet.
• Chocolatey is a tool for installing system wide applications such as Notepad++ or Git.
• Rob explains that it is built in PowerShell on top of NuGet.
• The guys talk about the simple process to install Chocolatey and install an application.
• Rob explains how Chocolatey was born.
• John S. asks what the process is to create a new Chocolatey package.
• The PowerShell command to install Chocolatey is: iex ((new-object net.webclient).DownloadString(“http://bit.ly/psChocInstall”))
• Jon G. asks what Chocolatey does behind the scenes when installing a package.
• Jon G. asks how to use Chocolatey to uninstall software Chocolatey installed.
• John S. asks if Chocolatey has been used in a way that wasn’t expected.
• The guys discuss the various ways of setting up a process to install multiple packages at once.
• Rob explains the difference between Chocolatey and Ninite.
• Kevin asks about the silent installs and how it works if the application doesn’t support silent installs.
• Kevin asks about the update story.
• The guys discuss learning and understanding PowerShell.
• Rob discusses the Chocolatey integration with Web Platform Installer.
• John S. asks about the reason behind writing Chocolatey in PowerShell.
• Kevin asks about Microsoft’s package manager, CoApp and how it relates to and is different from Chocolatey.
• John S. and Rob discuss how Chef, Puppet and Chocolatey could be used to spin up a new machine for a production deployment.
• Kevin asks about the fact that Rob is the owner of most of the Chocolatey packages and how he keeps track of updates to all those packages.
• Rob talks about the Chuck Norris framework and the following components of the framework:
• WarmuP -allows you to define templates for entire projects and change them as technology changes and you learn new things.
• UppercuT – is a conventional automated .NET build framework (templated NAnt). UppercuT is the insanely easy to use build framework.
• RoundhousE – is an automated database deployment (change management) system that allows you to use your current idioms and gain much more.
• DropkicK – is a fluent deployment framework that seeks to make deployments easier.
• Jon asks if the company Rob and Dru worked for when they were working on these projects was receptive to their open source development.
• Rob will be speaking on NuGet at CodeMash (it’s sold out) in January.

Show links:

• Chocolatey.org
• Rob Reynolds @ferventcoder
• Guest Host John Sheehan
• Nuget
• April video for creating a new Chocolatey package 6:46
• Keith Dahlby
• James Tryand
• Octopus
• Vagrant
• Ninite
• Web Platform Installer
• Pester
• CoApp
• Chef
• Puppet
• Change Detection
• Chuck Norris Framework
• Dru Sellers @drusellers
• Fluent Migrator
• Tarantino
• CodeMash

Download / Listen:

Herding Code 128: Rob Reynolds on Chocolatey and the Chuck Norris Frameworks

This week’s show notes were typed up by @RossFuhrman – Thanks!!!

• Scott asks Corey to start by explaining his software journeyman thing, or as Scott calls it “couch surfing in return for coding.” Corey describes how he transitioned from a traditional software developer job to training and speaking.
• Scott describes his experiences at a Coderetreat in Seattle – a series of 45 minute pair programming exercises with Conway’s Game of Life under a variety of constraints.
• Corey explains how Coderetreat got started at CodeMash 2009 as a way to intentionally practice writing beautiful code outside of the pressure of day to day work.
• Corey talks about how deleting your code at the end of every 45 minute session means you can concentrate on learning rather trying to complete anything.
• Jon asks if people are working towards any kind of graphical output, and Corey says that the focus is really on the code, and learning how to respond to changes and constraints.
• Twitter question from George Dinwiddie (@gdinwiddie) “What was the most interesting starting point for the Game of Life” Corey talks about people often start with traditional object oriented noun/verb approaches in the morning and move towards an outside-in mentality in the afternoons. He’s seen some interesting work with functional languages such as Clojure and J.
• Jon asks about the breakdown of programming languages that he sees people using.
• There’s a discussion of how setup and install can often eat up a lot of time at this kind of event, and Corey talks about how that’s not such a problem here: people show up with working development environments, are working at the testing level, and can just pair with someone who
• Jon asks what common patterns he sees people learn. Corey talks about some big changes in TDD focus and application design.
• Scott and Corey talks about the benefit of pairing with a lot of people at differing skill levels.
• Twitter question from Steven Proctor (@stevenproctor) “How often do you get to pair at these events” – Corey says that the facilitator role means you don’t get to pair, so he’s only been able to a couple times.
• Kevin asks how new pairing is to attendees, and if there’s any specific focus on learning how to pair better. Corey talks about some specific exercises which focus on paring techniques, including a Mute session (no talking, all communication through code) and Find The Loophole (in which the the coder purposefully tries to write the wrong algorithm while passing all tests).
• Scott says he
• Twitter question from from Maggie Longshore (@MaggieLongshore) “How he makes each code session unique so it doesn’t get monotonous. Share some tips for facilitators.”
• Jon asks about the upcoming Global Day of Coderetreat on December 3. Corey explains what will be going on worldwide, and how he’ll be exploiting a flight over the international date line to attend the full day sessions in both Sydney and Hawaii.
• Jon asks about some of the guidelines for listed hosting a Coderetreat, including a good (non-pizza) lunch and no cost to attendees. Corey says that in some cases there’s a deposit which is fully refunded provided you show up.
• Jon asks Corey how people can find out about a Coderetreat near them, and if it’s still possible to set up a Coderetreat if there isn’t one in your area. Corey says yes, and points us to Coderetreat.org for all information about the Global Day of Coderetreat on December 3.
• Jon asks Corey about his MercuryApp, a micro-journaling system with analytics that he and Sara Gray run.
• The guys chide Corey for slacking off by setting his Global Day of Coderetreat so low, and he talks about his difficult decision to exclude astronauts this time around.

Show Links:

• Coderetreat.org (Global Day of Coderetreat site)
• Coderetreat.com (Information on the Coderetreat format)
• Corey Haines (@coreyhaines)
• Conway’s Game of Life
• J Programming Language
• MercuryApp

Download / Listen:

Herding Code 128: Corey Haines on Global Day of Coderetreat

• Kevin and K Scott both just got MacBooks, they discuss what they are doing with them, such as using the emulator to test HTML5 apps for iPhone/iPad.
• Jon asks, “When you get a new mac, you open it up and rainbows come out of it. Do you have to install anything? How does that setup process work?”
• Kevin talks about development tooling such as HomeBrew and XCode. They discuss different tools and apps that they need to do development.
• Jon asks about twitter apps. K Scott uses the browser; Kevin is using the official Twitter app which seems pretty good except when it won’t launch the browser when clicking on the links in tweets.
• When upgrading, do you go through fresh install or remove programs? Jon talks about using Ninite to install programs you use a lot such as 7Zip, Audacity, Chrome, FileZilla, Skype, etc, because it manages everything for you and you don’t have to click through all the install dialogs.
• Also talks about using the Microsoft Web Platform Installer to get all of the web development stuff.
• They talk about the pros and cons of using Microsoft Office, and discuss using the Mac apps or Google docs or Office.Live.com.
• Jon is using Mesh to share between computer and sky drive; what kind of file sharing? K Scott is using Dropbox, says Live Mesh is important because of the remote desktop feature of Mesh. They talk about different file sharing companies and features, and talk about iCloud.
• Jon talks about the Windows Home Group feature, and how easy it is to share files, printers, media, etc., and talks about doing backups. Uses Space Sniffer to find big files.
• Jon got an SSD, so he made the old drive his D drive and used the SSD as his primary drive. If the SSD failed (which it did), he could just boot off the D drive.
• They discuss the placement of the files on the computer, whether to move to a second hard drive or partition, etc., and whether to use Libraries; they talk about searching for files in Windows. Some software apps disable the file indexer in Windows. When you install on an SSD, they disable some services like defrag, prefetch – it also disabled search.
• K Scott asks what kind of SSD Jon is using that is failing. Jon says it’s an OCZ Vertex 2, but he’s not sure it’s the drive versus the computer – gets blue screen on Windows, thinks it might be a hardware problem with his evil computer.
• Jon asks if they use Hibernate or Sleep? How often do they reboot?
• Kevin never uses hibernate. Jon will have a bunch of stuff running and will hibernate to save the battery on his laptop. Kevin thinks it burns slowly enough on Sleep, only hibernates when doing a full day of travel. Not worth it for a couple of hours.
• With newer laptop (16gb of ram), hibernating is a big deal. Jon ended up setting hibernate file size and tweaking the hibernate settings.
• MacBooks have pretty good battery life. The Air says it has almost 8 hours remaining; thinks that’s a little high, but it’s pretty good. Jon’s ThinkPad W520 is big, but gets around 7 hours, doesn’t have to worry about battery life; some optimizing settings make it difficult to use a projector.
• They discuss how often they repave their machines and the effect of using beta versions of software, how they go about getting back to work after repaving. How do you save your settings and reapply them after repaving?
• K Scott – windows get stuck off screen, can’t get them back on the main screen. Kevin has a utility that can help with that; it’s on his blog. Shows list of off-screen windows – can pick one and it will move it back to the main window.
• Jon finds uninstall really works pretty well now, whereas before it was just a cruel joke.
• K Scott talks about pulling pictures off of a Windows 6 phone. Doesn’t attach as an external drive, it installs Windows Mobile Device Center. Nooooo!!!!!
• Jon finished his office and moved into it. What about a standup desk? Found something simple from IKEA that could be used for part of the day. They talk about the idea of a standup desk.
• What about doing your work on a treadmill with a laptop? (Idea from a Neal Stephenson book). What if you did that for 15 to 30 minutes a day? Several people on twitter responded with information about their setups doing this.
• Simple way – found something for forty bucks on amazon that the laptop would rest in. Would just walk, not jog. Others have taken the control thing apart and put in a desk. Let us know if you’ve tried something like this.
• They discuss ergo keyboards, and using Synergy or Input Director for sharing a keyboard and mouse across multiple computers.
• K Scott has a problem with the keyboard on the Mac; bothers his hands, especially when using it for hours. They like Lenovo keyboards.
• Jon – some keys don’t map between Mac and Windows. Kevin uses a Microsoft ergo keyboard with the Mac, and out of habit still uses those keys, and it sometimes has a weird impact.
• They talk about Vim and Mac Vim.
• Jon switched from using a mouse to using a tablet. Mouse is what really hurts your wrist. Kevin moved his mouse to the left for years for the same reason. K Scott likes the TrackPoint pointing stick on the Lenovo.  Kevin’s never been a fan of the trackpad on the laptops, but the Mac trackpad is brilliant.
• Talk about using different software to help readability, like Readable, which uses Google web fonts. Can customize it to meet your needs. Makes it easier to read web pages.
• Jeff Atwood posted a blog entry about backlights behind the monitor like LED glowstrips. You can have a dark workspace and lower the contrast using backlights.
• And now for something completely different . a lightning round.
  • What’s your favorite browser?
  • What’s your favorite Javascript library this week?
  • Did Adobe really kill Flash? Does the lightning round really work? Does anyone expect the Spanish Inquisition? Why do people keep making websites that exclusively use Flash, especially restaurants? Is the future of video really animated gifs?

Show Links:

• Homebrew (OSX)
• Ninite (Windows)
• Web Platform Installer (Windows)
• Dropbox (Web)
• Windows Live Mesh (Windows, Web)
• Front And Center! (utility from Kevin that locates offscreen windows)
• Ikea Utby Bar Table
• REAMDE (book which mentions treadmill desk)
• treadTray
• Llewelyn Falco’s Treadmill Desk
• Microsoft Natural Ergonomic Keyboard 4000
• Mouseless Computing (blog post from Jon)
• Synergy
• InputDirector
• Boot Camp mappings for Windows
• VIM
• Readability
• Readable
• Bias Lighting (Jeff Atwood)
• Backbone.js
• Raphael
• Underscore.js
• Flash to Focus on PC Browsing and Mobile Apps; Adobe to More Aggressively Contribute to HTML5
• Animals Being Dicks (animated GIF’s)
• If We Don’t, Remember Me (cinematic animated GIF’s)

Download / Listen:

Herding Code 127: Setting up your Computer and Work Area

This week’s show notes were typed up by @RobinDotNet – Thanks!!!

• Jeff talks about video games as a gateway to programming. Jon and Jeff talk about how video games teach a skill which is valuable in programming – the ability to accept and work with arbitrary rules.
• Jeff talks about the crappy games he has created.
• The guys talk about how Rocksmith can teach you how to actually play a real guitar. The guys compare Rocksmith to Rock Band and Guitar Hero, and Jeff talks about how really learning guitar skills takes work, and Rocksmith and Rock Band take two very different approaches.
• There’s a discussion of how well Rocksmith senses what you’re playing, and how musical performances are by nature interpretive and imprecise.
• The guys talk about how video games can lead to real world knowledge and skills.
• Jeff brings up the concept of gamification and how it can be used to get people to learn something worthwhile. He discusses the balance of fun and learning, and the importance of keeping learning fun.
• Jeff talks about Khan Academy, and how it leverages gamification.
• Jon talks about Codecademy – free, interactive programming classes with some game-like features.
• K. Scott talks about the Roblox game and using Roblox Studio to do some basic programming.
• Jon talks about the World of Goo, and how he’d helped his own daughters build their own levels in World of Goo.
• Jeff talks about incidental learning and how games can encourage it.
• Jeff says programmers need more points of reference than XKCD to explain things.
• Jeff and Kevin talks about the power of gamification as a psychology hack, and how it can be used for good and evil.
• Kevin brings up the idea of addiction to Stack Overflow. Jeff talks about the ways that Stack Overflow tries to prevent burnout of contributors.
• Jeff talks about the balance of effort and reward, and how Stack Overflow sometimes over-rewards people for minimal work on their part.
• The guys talk about video games that encourage teamwork, such as World of Warcraft, Battlefield 3, and Half-Life.
• The guys discuss Microsoft Kinect and compare it to the Nintendo Wii. There’s a discussion of the controller responsiveness and selection gestures for these systems, and the importance of writing a game that’s native to these new platforms as opposed to simple ports.
• Jon takes from questions from Twitter about Jeff’s favorite retro games, and Jeff says video game nostalgia is overrated – he’s really excited about the new games like Battlefield 3.
• Kevin asks about MAME and home arcades. Jeff says it was interesting to have build two home arcade machines, but it’s not something he’d want to spend anymore time on.
• Jon talks about Braid, and the hidden insanely tough extra game of finding all 8 stars.
• The guys congratulate Jeff on his recent news that he’s expecting twins, and he signs off to play Battlefield 3.

Show Links:

• Jeff Atwood (@codinghorror http://www.fakeplasticrock.com http://codinghorror.com)
• Separating programming sheep from non programming goats
• An Empirical Comparison of the Accuracy Rates of Novices using the Quorum, Perl, and Randomo Programming Languages
• RocksmithRocksmithRocksmith / Rock Band 3
• Penny Arcade – Extra Credits
• Joi Ito: Leadership in World of Warcraft
• Khan Academy
• Codecademy
• Roblox game
• Roblox Stack Exchange
• Roblox Studio
• World of Goo / World of Goo Level Editor
• SE Podcast #23 – James Portnow
• Loss aversion
• The Sunk Cost Fallacy
• 59 Seconds
• Battlefield 3
• XKCD – The Problem With Wikipedia
• John Resig joins Khan Academy
• Xbox Kinect
• Dance Central 2
• Your Shape 2012
• Braid / Braid – All 8 Stars
• Yars’ Revenge
• Bitcoin crash

Download / Listen:

Herding Code 126: Jeff Atwood on Video Games and Gamification

This week’s show notes were typed up by @rossfuhrman – Thanks!!!

• They talk about their backgrounds and combining their different skills to build something pretty awesome.
• K. Scott says Truffler has a REST API and can be called from several languages (.NET, Java, js). How to send queries, where is the data?
• Joel explains they’re using Elastic search, which indexes JSON documents; you push data to it in the form of JSON, then query it using JSON. The data is stored, but the point is to build awesome search.
• Marcus points out you can get a Truffler in a box, where you get a server to your house so you can run it inside your own internet if you like.
• K. Scott mentions the examples using the C# API on the Truffler home page. Do you convert that to a URL for your service?
• Joel talks about using Elastic Search and the bits they’ve added on top of it, including the various integrations or client APIs they are making available.
• K. Scott says he ran through their example; was able to just bang his way through it without having to dig into the documentation too much.
• Joel: Instead of bringing your data to the search engine, we’re trying to bring the search engine to you, so you can query it in a way that feels natural in C#. That’s the whole point of Truffler.
• Jon Asks about being able to search for a keyword and also have a geographical search and how that works.
• Joel says they search for the keyword and then filter by coordinates, which does not affect relevance. Can specify that matches for the keyword have double the relevance of non-matches.
• Talking about the ability to modify relevance and rank criteria higher and lower.
• K. Scott asks if they contribute any patches or make any patches or augment anything to the technology they are building on?
• Henrik has gone through the elastic search source code quite a few times. Found bugs, but not trying to augment it, just trying to find a way to package it in a nice way.
• Jon asks about the document search capabilities (pdf, xml, word, etc) – part of elastic search? Or did you have to do some of that work?
• Marcus replied that most features are basically from the elastic search core functions. The mods we have are just bug fixes. Not exposing any new functionality, just providing some features that are a little different from the core project.
• They’re trying to make search easier so you don’t have to analyze and then index your data; they’ll do that for you.
• Jon asks about highlighted words and bacon. Joel says it’s configurable. Can ask for one big fragment with highlighted keywords, or several small fragments, comes back as a separate fields in the JSON document. To make it as easy as possible, they are using LINQ syntax. Example: Select.As Highlighted()
• Discussing how to add search to your website/blog.
• They’re using JSON.NET. Discusses client class and using extension methods.
• They discuss how to do a Google-type search – typing in textbox, brings results.
• K. Scott: Any support for Word and PDF? Joel: Yes, it’s out of the box with Elastic Search; handles all kinds of formats.
• K. Scott asks what the biggest challenge is. Joel: Everything. Branding, building the product, figuring out the market.
• K. Scott says this is actually a product and a business now; was that new for the three of you? Joel says yes; were forced into it when working for a customer together who needed to search and query data not stored in a normalized database. Was the initial seed idea of Truffler.
• K. Scott asks about node. Henrik said they use node as a reverse proxy to do authentication for Elastic Search.
• They know what it can do; they can control how it’s used. It’s scary and exciting to see how people are using it.
• Marcus said have to know what queries they want before they come; they are adapting it to handle so many queries without knowing what people are going to use it for.
• Jon asks about performance / caching results on client side. Joel says servers can handle a lot, but there’s always latency. With .NET, allow you to cache search queries, which are serialized. For Get requests, don’t have caching; they’re pretty quick, but will add them in the future.
• K. Scott asks what’s next. Lots of features; very interested in feedback. Have partners/customers testing with large sets of data. Lots of things in the .NET API they don’t expose but would like to. Want to provide as much flexibility as possible.
• K. Scott asks about storing his own metrics. Providing some metrics about how his search is being used? They’re working on that, and SSL, encrypted indexes in planning stage.
• Jon asks about support for custom synonyms; they explain what that means.
• Plans and prices – free for developer. Then have basic and premium plans depending on how much you’re using it, what features you want, etc.
• Joel says they have support for inheritance.
• Jon asks about pricing. With developer license, if have open source project, get quite a bit of functionality and features.
• Joel says that for developers, they want to encourage use. Would like feedback.
• Jon asks how this compares to other search engine options and other document databases like RavenDB? Joel says you can use it for a document database, but that’s not the primary purpose of it. Raven is an awesome document database with text search, where this is awesome text search with basic document database capabilities. Henrik says if you take hardcore search, their main idea is not to provide hardcore search, but to enable developers to utilize search without being search experts.
• Released client for Episerver, used widely in Sweden. Truffler will take care of indexing and hook up to events for you. They have the concept of filtering (using the LINQ where method), and have the ability to extend that.
• K. Scott asks if this is open source. Joel says not exposing the source code at the moment. The .NET API is a very important part of their product, do some really cool things with it, would like to keep it to themselves. May release it in the future.
• Truffler web site is truffler.net. On the about page, there are links to twitter and Joel’s blog.

Show Links:

• http://truffler.net
• Joel Abrahamsson: Twitter, Blog
• Marcus Granström: Twitter
• Henrik Lindström: Twitter
• elasticsearch
• Raven DB
• Truffler package on NuGet
• Read-only service at http://sample.truffler.net/ (downloadable from https://github.com/200OK/TrufflerSample)

Download / Listen:

Herding Code 125: Truffler with Joel Abrahamsson, Marcus Granstrom and Henrik Lindstrom

This week’s show notes were typed up by @RobinDotNet – Thanks!!!

• Jon asks why Glimpse was created.
• Anthony gives a high-level explanation of what Glimpse does.
• Glimpse is for your server what Firebug is for your browser.
• Glimpse exposes a plugin architecture that allows it to be extended as necessary.
• Kevin asks if Glimpse can be leveraged from application code. Nik explains it is possible, but 99% of the functionality you need will not require any extra code in your application.
• You can point your logging framework to Glimpse and then you can see log entries relevant to the request.
• The guys talk about how Glimpse fits in with NLog, ELMAH, mvc-mini-profiler, etc.
• Nik says Firebug + Fiddler + Glimpse is the trifecta of development tools.
• Jon asks how Glimpse can be used to help a user experiencing trouble with a production site.
• Jon asks about running Glimpse in production.
• Twitter question from @danielauger: “What was the most difficult metric to tap into?”
• Anthony and Nik explain all the detail that is tracked in the Execution tab of Glimpse.
• Anthony talks about how they decided to display all the data that Glimpse has.
• Jon and Anthony talk about how Glimpse could be used to improve page response times.
• Kevin asks about the performance overhead of using Glimpse and using it in production.
• Nik explains how Glimpse plugins are enabled/disabled.
• Jon asks about seeing the validation rules for a particular request.
• Anthony talks about what is added in to core Glimpse versus what goes in to Glimpse plugins.
• Jon asks about how Glimpse handles Ajax.
• Kevin asks about record-and-replay functionality in Glimpse.
• Jon asks about the implementation of the client side display of Glimpse data.
• Nik explains how to configure Glimpse to easily compare differences between test, staging and production environments.
• Jon asks about the future of Glimpse.

Show links:

• Glimpse: git repo, Glimpse for ASP.NET NuGet package, Glimpse for ASP.NET MVC NuGet package
• Anthony van der Hoorn (@anthony_vdh)
• Nik Molnar (@nikmd23)
• CodePlex documentation for adding Glimpse manually
• NLog
• ELMAH
• mvc-mini-profiler
• Firebug
• Fiddler
• C4MVC talk on Glimpse
• Fluent Security

Download / Listen:

Herding Code 124: Anthony van der Hoorn and Nik Molnar on Glimpse

Note: Thanks to @rossfuhrman for typing our show notes this week!

• Scott Koon asks why Nancy was developed and what are the problems going up against ASP.NET.
• Andreas explains Nancy is a lighter approach and doesn’t get in the way.
• Andreas explains a basic Hello World – 5 lines of code, and Steven points out a Nancy app fits in a single Tweet.
• Nancy has No System.Web dependencies – just depends on the Client profile, and works great on Mono.
• Jon asks about support for OWIN, a Rack equivalent for .NET. Combining Nancy and OWIN allows you to have an end-to-end OSS solution.
• Jon asks about support for view engines, and Andreas says that Nancy supports most major view engines including Razor and Spark. There are quite a few Nuget plugins.
• Andreas points out that you can do most things in Nancy that you can do in ASP.NET MVC.
• Jon asks if you can add Nancy to an existing ASP.NET MVC app.
• The group discusses the value of having many competing web frameworks.
• Steven explains Nancy isn’t about crushing the competition, just providing a different approach that some people might prefer.
• Jon asks Andreas about his post about the value of OSS being the vision not the code.
• Jon asks about web application security for Nancy – since it’s a lightweight framework, am I on my own when it comes to security? Steven explains the security features in Nancy, and how they work without requiring a dependency on System.Web.
• Jon asks how many users of Nancy there are.
• Kevin asks what the most challenging part of developing Nancy has been. – Steven: HTTP implementation and the syntax simplicity. Andreas: fighting C# syntax limitations.
• Kevin asks whether Nancy is trying to be ASP.NET MVC.
• The group discusses extensibility and custom configurations.
• Andreas explains Nancy will be adding static and trace diagnostics in the future.
• Twitter question from @bitbonk: “Relate or compare NancyFx with WCF Web API.”
• Twitter question from @codereflection: “can we get around having to mock httpcontext w/ Nancy? Do we even need to?”
• Via Twitter, @kppullin asks about how the Nancy team decides how to add features.
• Jon asks about the best places for interested users to get information, and there’s a discussion of documentation, Google Groups, Twitter, and screencasts.
• Jon asks about a NuGet packages that would have some samples. Andreas explains why the samples are included along with the source code on Github instead.
• Kevin asks whether they do performance testing, and how Nancy’s performance stacks up.

Show Links:

• NancyFX git repo, NuGet package, Google Group, @NancyFx
• Andreas Håkansson (@TheCodeJunkie)
• Steven Robbin (@Grumpydev)
• Nancy, Sinatra and the Explosion of .NET Micro Web Frameworks with Andreas Håkansson

Download / Listen:

Herding Code 123: Andreas Håkansson and Steven Robbins on NancyFx

Note: Thanks to @rossfuhrman for typing our show notes this week!

• Kevin asks how Bert got started with Node.js. Bert explains that he was working on a PHP based system which had a good amount of logic in Javascript, and he started looking to node as a way to consolidate that logic.
• K. Scott ask Bert about how you’d go about sharing Javascript between client and server.
• Kevin asks how the Windows port of Node.js got started, and whether there was any resistance to it.
• Jon asks if the eventing model in Windows was one of the more difficult things Bert had to work on. Bert explains that getting REPL (read evaluate print loop) to work on Windows as it did on Unix was actually one of the more difficult challenges at the beginning.
• K. Scott asks about experience of running Node.js. Bert talks about how Node.js runs as an executable, and it’s up to you to set up an HTTP server.
• Kevin asks about the team that’s working on the Windows port.
• Kevin asks Bert for more info on technical challenges on getting Node.js not only working on Windows, but really performing. Bert describes some challenges in implementing I/O Completion Ports, spawning child processes, etc.
• Jon says that some of the initial negative feedback he’d seen on the announcement of the Windows port was concern over negative performance implications for the Unix version, and Bert says that one of the criteria they’re working under is that Unix performance not be degraded.
• Kevin asks Bert if he had a background in high performance networking, of if he’d been  figuring things out as he went along. Bert explains that he and the team have had a good amount of time to work on this, so they had a pretty good idea of how to solve this.
• Jon asks about performance testing, and Bert describes some of the load tests that they use.
• K. Scott asks about if most Node.js modules will work on Windows. Bert says he guesses 90% will work, and the ones that won’t are making operating-system specific assumptions.
• Jon asks Bert about his work on libuv, the abstracted platform layer for Node.js, and Kevin asks about the process of designing this abstraction layer.
• Kevin asks Bert if there are places where Windows is more flexible or powerful than Linux. Bert explains that since node was written for Unix first, it wasn’t built to exploit Windows advantages, but with Windows kernel mode HTTP stack might be useful in the future.
• K. Scott asks if the port could have been aided by open source projects like Cygwin. Bert explains how Cygwin isn’t really helpful in making node.js work well on Windows.
• Jon asks if dropping support for Cygwin in Node.js will affect users, and Bert says the only effect may be for addons which are written so as to be Unix-only.
• Kevin asks about Windows support for NPM.
• There’s a discussion about the different hosting options on Windows including Azure and iisnode. Kevin asks about service hosting to allow socket level access (below IIS).
• Kevin asks if there’s a plan for cross-platform system support for modules that need native access. Bert talks about changes to npm to support binary hosting so operating system specific binaries can be automatically downloaded.
• Kevin asks if there will be a focused effort to get node module authors to support Windows.
• Jon asks about multi-core scenarios. Bert talks about different options, explaining that iisnode can help with this, but he hasn’t seen options for interprocess communication in iisnode or in in either multi-core scenarios.
• Kevin asks about the use of gyp for the node.js build process and about Bert’s development environment on Windows.
• Kevin wraps up by asking Bert how to pronounce his twitter handle.

Show Links:

• Bert Belder (@piscisaureus)
• Node.js
• Porting Node to Windows with Microsoft’s Help (announcement post on blog.nodejs.com)
• I/O Completion Ports (MSDN)
• ApacheBench
• libuv (github)
• Installing and Running node.js applications within IIS on Windows – Are you mad? (Scott Hanselman post about iisnode)
• gyp (Generate Your Project)

Download / Listen:

Herding Code 122: Bert Belder on porting node.js to Windows

• Kevin jumps right into it by asking Sara about what’s been going on over the past year. Sara goes back to what was on their minds as they were first getting started with their first class, and how that’s grown to 6 cities worldwide, and their original New York chapter offers 20 classes a month with 5 teachers.
• Kevin asks where the other teachers came from, and Sara spins a tall tale about flamethrower classes. Well, maybe it’s true, but I find it a bit suspect.
• Kevin asks about where the classes are held.
• Jon asks about how the money part works out. Sara explains how the class fees, donations, and teacher payments all work out.
• Kevin asks Sara about about what tools they teach, and Sara mentions Aptana.
• Jon asks for some success stories and Sara tells a few.
• Kevin asks how many students go through several classes; Sara says they see about 25% frequent fliers.
• Jon asks if there’s some measurement of how much the students actually learn. Sara explains that the classes include a good amount of hands-on work and homework, and that she and the other teachers continue to learn how to gage when students are getting lost.
• Kevin asks if there are some students that just don’t get it, and Sara says that some students have a tough time understanding that a single missing character can break a whole program. Everyone commiserates about this fun part of software development. Jon speculates that young women may be missing out on some of the split between cold logic and reason because they don’t play enough video games.
• Jon notes that a lot of real world computer programming involves problem solving and support network and asks if students are equipped with those things. Sara talks about how anyone watching her code will see a good amount of debugging; additionally she teaches students about how to use StackOverflow so they can get their questions solved.
• Kevin asks how the curriculum and courses have evolved over the past year. Sara and Jon talk about the amount of time and effort involved in preparing decent training materials.
• Kevin asks about changes in teaching approach over the course of the past year. Sara said she’s moved from code-only to using some slides, and that when writing code it’s important to walk through it in pretty good detail.
• Kevin asks what’s been different from expectations, and Sara talks about both the amount of interest and community goodwill.
• Kevin asks about how Girl Develop It has spread to other cities, and asks about how much of the content is shared between cities.
• Jon asks about how the branding and design is handled.
• Jon asks if there are advanced classes or seminars.
• Jon asks Sara what sort of projects she’s been working on lately. Sara says it’s pretty much all Javascript lately.
• Kevin asks if there will be a node.js class (drink!)
• Kevin asks what’s next for Girl Develop It, which prompts Sara to talk about the first Girl Develop It hack-a-thon. Apparently these are like a guy hack-a-thon except with less pizza and body odor and more resort and catering.
• Kevin asks if Girl Develop It could develop into a full time gig. Sara says that all the leaders love developing and don’t want to give that up, so they’re still trying to figure that out.
• Jon asks how listeners can support Girl Develop It. Sara lists a range of options, including book, laptop donations, and meeting space. Kevin asks about cash contributions.
• Jon and Kevin note that there are no West Coast US branches. Sara mentions that a bay area location may start soon.
• Kevin asks about the 15% male attendance in Girl Develop It, and Sara explains how that works.
• Jon asks if there’s potential for virtual events and video recordings. Sara explains that, while it sounds great logistically, it misses out on a lot of the most important aspects of the Girl Develop It classroom experience. They’ve got trial running in the Columbus branch, though, so they’ll see how it goes.
• Sara teases about an interesting hack-a-thon project they did recently using the Aviary API’s called Stash Your Stash, which removes moustaches from photos because "they’re super creepy!"

Show Links:

• Sara Chipps (@sarajchipps)
• Girl Develop It
• The Madagascar Institute
• Aptana
• Hamptons Hackathon for Humanity
• Commuting In Traffic

Download / Listen:

Herding Code 121: Sara Chipps updates us on Girl Develop It at one year

• Scott K asks about the pricing of Adobe products. Ryan explains why things are priced as they are and talks about the subscription model alternative.
• Jon talks about the open other free or inexpensive alternatives for beginning Adobe development since the formats are generally open sourced. Ryan agrees and also explains that Adobe’s entire pricing model is built around tools, whereas Microsoft’s includes both tools and servers.
• Jon asks about the licensing around Flash Media Server. Ryan explains that it’s not something general developers will need to deal with.
• Scott K speculates around the idea of appliances from Adobe which would be complete video / media processing systems. Ryan says he thinks that’s interesting but he doesn’t expect anything like that to happen.
• Jon asks about the general trends away from some rich internet abuses in the past. Ryan and Jon talk about the polyfill approach for using Flash and RIA technologies to augment browsers when the features aren’t supported. Ryan and Scott K talk about how developers and the tech press have quickly forgotten that many of the new emerging browser capabilities (typography, media, animation) are modeled after capabilities that RIA technologies initially pioneered.
• Scott K points out that this is a good segue to the new Edge tool. Ryan talks about how Edge is a designer tool that creates CSS3 and JavaScript animation using the timeline that Flash designers are used to. Jon mentions that this makes more sense to him when thinking about Adobe primarily as a developer tools company rather than a platform oriented company.
• Jon asks about Adobe support for HTML5 / CSS3 development in Edge with Flash fallback. Ryan talks about how they generally keep them separate, and if browser-based animation isn’t supported it just won’t play.
• Kevin asks about how Edge affects the accessibility of the underlying content.
• Jon asks about how Flash Builder 4.5 allows for developing native iOS and Android applications. Ryan explains how it works and clarifies how it complies with Apple developer guidelines. There’s a mention of the popular Mono apps which run on iOS.
• Twitter question from Chris Edwards: "What are the are the best tools for automated testing of Flash UI’s" – Ryan recommends HP Quick Test Pro
• Scott K asks about Adobe Air – it seemed great, but seems to have kind of fallen out of favor. What’s the deal there? Ryan talks about how Air was both a great, bold idea, but also a new challenge for Adobe, in that Air applications are much longer running than most Flash apps.
• Jon asks about some annoyances in installing updates for Air, Flash, etc. Ryan explains some of the reasons for the updates. Jon asks about the possibility to add in more of an auto-update experience.
• Jon asks Ryan about some of the new features in Flash. Ryan talks about a lot of features, including Stage Video and 3D GPU support and graphics features. Scott K. asks if there are opportunities for leveraging WebGL, and Ryan says that there have been discussions about that but nothing’s in progress yet.
• Ryan asks the guys what they’re expecting at at BUILD, and they all clam up. Scott K. ask about Flash on Windows Phone. Ryan says it’d be great, but he’d be surprised given the Silverlight support on Windows Phone. Kevin’s happy that speculation will finally stop. Scott K. talks it’s good that developers are having to care about memory and CPU usage again.
• Ryan talks about the difficulty of bringing richness and creativity to the client without adversely impacting performance.
• Scott K asks about the current state of Adobe Labs. Ryan points out that the Adobe MAX conference is coming up in October, so Labs will probably be pretty quiet until then.
• Jon asks about Muse. Ryan explains that really targeted at print designers who want to create web content, so it’s not really a tool for web designers or developers.
• Jon asks about some Adobe client products which are developed in Air.
• Scott K. asks about what big surprises may be happening at MAX this year. Ryan and and Scott K. speculate a bit more about BUILD, and Ryan tells listeners who recognize him at BUILD to please say hi. Jon says he might sneak in if he can locate a catering costume.

Show Links:

• Ryan Stewart (@ryanstewart)
• Adobe Labs
• Adobe MAX
• HP Quick Test Pro

Download / Listen:

Herding Code 120: Ryan Stewart on RIAs and all things Adobe

• We start with a listener question from @tpdorsey (Terrence Dorsey): “*Printed* books? If so, why bother? I ask this as a print writer and editor for 17 of last 20 years.”
• There’s a discussion of the value that the editorial process adds to books as compared to blog posts.
• Twitter question from @schwarty: “Best way to work a first time deal? Submit queries? Try to team up with co-writers?” Phil, Brad, Jon, K. Scott, and Jesse tell stories about how they got their first book deals.
• Phil notes that most authors get a start in other mediums – blogs, magazines, possibly StackOverflow in the future.
• Jesse talks about his investigation of self-publishing. In the end, he decided that the editorial process tipped the scales towards working with a publishing company.
• Jon references Twitter questions from @devhammer and @jglozano on dealing with procrastination, making time to write, etc. He points to positive pressure of working for a publisher under a schedule and a contract to get the book out the door. Brad talks about how peer pressure from other authors to keep up is also helpful.
• There’s discussion about the challenge writing up an outline before starting the book. Phil talks about how the publishing industry in general is pretty stuck on older technologies like FTP, and in general the process feels like waterfall software development.
• Jesse says that if you’re reasonably on schedule, publishers are pretty flexible about changes to the outline.
• Brad answers listener questions from @stevenproctor “Have you found e-readers coming into their own to influence how you think about book?” and “has it changed how you think about layout/presentation for cross format reading” saying that it was difficult to write without seeing what the end result would look like, but he was very happy when he saw the end result, both in print and the e-book format.
• Jon talks about how working with book templates from various publishers has taught him to appreciate the use of styles in Word, explaining a case where he was able to search for code snippets based on the styles that were used.
• Kevin asks some interesting questions about whether working on the book puts pressures on when to ship the product, and whether writing a book about a product points out features that should be changed. Brad explains that the king of product changes due to writing (blogging in this case) is Scott Guthrie.
• Phil talks about how Eilon (the technical reviewer) was good at keeping him from digging too far into minute details that nobody would care about. Jon explains that Eilon pointed out that the Controllers chapter was going way into the weeds before actually showing the most common use case, and Brad says that he’s in good company with an example from Charles Petzold’s book on Windows programming.
• Jon talks about the tricky chicken-and-egg situation with trying to explain the MVC pattern in depth, since an in-depth explanation of the Model, View, and Controller requires an in-depth understanding of the other components. Jon asks Jesse about how he handles that, and Jesse talks about the importance of having a model user and getting volunteer readers as you’re writing.
• Jon talks about the benefit of working with other authors. Brad talks about the this is more important with products with quick release cycles, and Phil compares book writing with software development techniques.
• There’s a discussion on ensuring a consistent voice in a book with more than one author.
• Phil, Jon, and Brad discuss the conflict between beginner and advanced content. Are the experts who are asking for advanced content representative of most readers? Phil points out that writing advanced content is a lot more fun, but limits the audience. Can a book please everyone? Is there a way to include beginner and advanced content? Jesse describes some ways he handles this, and says that it’s important to set expectations.
• Jon talks about the decision to remove NerdDinner, referring instead to the MVC Music Store tutorial.
• Jesse says that it’s remarkable that books are still selling well, since they’re competing with blogs, tutorials, videos, etc. He speculates that the main selling point for books now is in context: telling a story. Jon asks how he manages to do that.
• Phil talks about the decision to put all the book’s code samples in NuGet (triggering the Haacked NuGet Drinking Game clause).
• Jesse talks about the mismatch between the publisher’s requirements for a flow of completed chapters and the software developer’s desire to refactor.
• Jon asks K. Scott how writing magazine articles compares to writing for a book.
• That’s pretty much it.

Show Links:

• Jesse Liberty (@jesseliberty)
• Phil Haack (@haacked)
• Brad Wilson (@bradwilson)
• Professional ASP.NET MVC 3 on Amazon and at Wrox.com
• Jesse’s dozens of books on Amazon
• Eilon Lipton

Download / Listen:

Herding Code 118: On The Writing Technical Books (with Jesse Liberty, Phil Haack, and Brad Wilson)