Herding Code

View Top 200 Chart

Back to Rankings Page

Latest Episodes:

Herding Code 206: Rachel Appel on Accessibility and Unit Testing Jul 23, 2015

Show notes

Episode 206

While at NDC Oslo, K Scott and Jon talked to Rachel about accessibility (web and otherwise) and testing.

Download / Listen: Herding Code 206: Rachel Appel on Accessibility and Unit Testing

Show Notes:

Accessibility

(00:18) Jon starts by asking Rachel what aspects of accessibility she addressed in her talk. Rachel overviews some aspects: visual, auditory, motor and cognitive needs.
(02:20) Rachel describes how increasing font size on a page is a really quick change that helps a lot of people, pointing out that eyeglasses are an accessibility technology.
(02:50) Using HTML semantic tags and ARIA attributes help people who are using screen readers to navigate your site - otherwise screen readers have to read through ads, page headers, etc. for every single page.
(03:45) There are 1.4 billion people with some kind of accessible needs.
(04:06) K Scott asks how well modern screen readers handle things like semantic HTML markup. Rachel says yes, and also mentions alt tags for images. Jon and Rachel discuss how easy it is to just rename divs to semantic tags like header and nav.
(05:13) Jon asks what ARIA is. Rachel says it stands for Accessible Rich Internet Applications and describes how ARIA attributes can give hints to screen readers for things like required fields and validation errors.
(06:44) Rachel recommends that listeners download a screen reader like NVDA or WebAnywhere, blindfold yourself and take some time navigating their sites to understand the experience.
(07:28) K Scott asks about building SPA sites with technologies like React, Angular, Ember. Rachel says that ARIA elements still work, and there are ARIA and semantic elements that indicate to screen readers that navigation is occurring. K Scott asks if navigation within a SPA causes the screen reader to start over; Rachel says that it does and recommends using skip links. Rachel recommends visiting the accessibility site webaim.org, which shows a good example of using skip links.
(09:25) Jon asks how Rachel got interested in accessibility. She's worked on a lot of government sites which require accessibility standards, but she's just personally interested in making sites that are easy to use. She describes some of the frustrations in browsing websites with ads and modals, then points out that it's even worse for users with accessible needs. Users with accessible needs make up 20% of the population, so you can easily justify any extra work as worthwhile just in expanding your user base by 20%.
(12:30) K Scott asks if Rachel has any other resource recommendations. She recommends using the WAVE scanner on the WebAIM site, which indicates a number of issues including contrast.
Jon asks about color blindness considerations. Rachel says that it's also important - Facebook is blue because Mark Zuckerberg is colorblind. She recommends using a tool called the Color Oracle. Rachel and K Scott discuss a number of considerations to make sure your sites and applications make sense to users with color blindness issues.

Testing

(15:55) Rachel gave another talk about testing with ASP.NET MVC. She covered xUnit for testing application code, qUnit for front-end testing, and UI automation testing. She recommends starting with unit testing, then adding in front-end and automation testing.
(16:50) Rachel thinks UI automation testing is kind of a hidden gem - Visual Studio has coded UI tests, which can emulate user actions, which just records your UI interactions so that it can play them back later. K Scott asks about timing issues and Jon asks about use with single page application. Rachel says just consider coded UI tests as a user - you can even have a QA or actual users click through the site and record their actions. K Scott asks what versions of Visual Studio support it. (ed. note: the recorder is only in Visual Studio Enterprise).
(18:50) K Scott asks what Rachel does to relax when she's not testing and calling people out for accessibility issues, and Rachel tells us her upcoming travel plans.

Show Links:

Rachel Appel (www.rachelappel.com, @RachelAppel)
Video: Designing and Programming Accessible Website and App UIs
Video: All Your Tests Are Belong To Us
NVDA
WebAnywhere
WebAIM
Color Oracle
Visual Studio Coded UI Tests

Herding Code 205: Udi Dahan on Starting a Company Based on an Open Source Project Jul 02, 2015

Show notes

Episode 205

While at NDC Oslo, K Scott and Jon caught up with Udi Dahan to discuss his experiences in building a distributed company (Particular Software) to offer support and services for NServiceBus and related technologies.

Download / Listen: Herding Code 205: Udi Dahan on Starting a Company Based on an Open Source Project

Show Notes:

Hello There
- (00:18) K Scott introduces Udi Dahan, whom we last spoke to in 2010.
Growing from an open source project to commercial product: how and why
- (00:41) Udi describes why he started a company to better support the NServiceBus community. On his own, he wasn't able to both support himself doing NServiceBus training and the NServiceBus project. He decided he was doing his users a disservice by continuing the free open source model, but he wasn't sure it would work since there weren't really precedents for taking an open source project commercial in the .NET world.
- (03:17) K Scott asks Udi about the global reach of his distributed company.
Commercial Software and Licensing Are Hard
- (04:10) Udi describes the learning curve to start selling a commercial product - complications with contracts, legal issues, etc. Pricing is complicated, too, because companies are structured so differently.
- (06:43) K Scott asks if each customer requires a separate license.
- (07:11) Jon asks what commercial model they settled on. Udi explains that the "call for a quote" model is common for large customers, but for "normal" customers it's generally $25 per month for a developer machine.
- (08:15) Jon asks what changed with respect to the license and code availability. Udi explains that the code is still on GitHub, the license just changed for cases where it's being used commercially and developers don't want to release their code. The code is now under the RPL - the Reciprocal Public License.
- (09:12) Jon asks about the difference between the RPL and the AGPL licenses. Udi explains that AGPL explains that AGPL only requires releasing your code to your users in order to use the code for free, so there's a loophole for cases like large intranet deployments. RPL requires releasing your code to the world for free use, not just to your users.
- (10:37) Jon says he's happy to see open source as a thriving business model. Udi clarifies a bit - the common approach is a service based open source model, but this it really pushes you towards working with a few very large customers. The problems with this approach is that you're both subject to large risk if you lose your giant customers, and you're competing with enterprise vendors who have deep pockets.
Running a Distributed Company
- (13:44) K Scott asks Udi how he manages a growing, distributed company. Udi says that it's good that the growth doesn't happen all at once.
- (15:15) Jon asks how they handle communications. Udi says it's important to write everything down and to make use of lots of web conferencing. All web conference meetings are recorded so people can catch up later. Jon says says he thinks that writing everything down makes things easier for your company over time. Udi says he wouldn't say it's easier, it's more of a maturity forcing function - if you're able to get through it, you're able to do a lot more and get new employees up to speed a lot faster.
Surprise Lightning Round!
- (18:43) K Scott springs a surprise Lighting Round on Udi!
- (18:56) Microservices
- (20:27) CQR
- (22:03) Event Sourcing
(26:43) K Scott asks what Udi does to relax in his spare time. Udi says he's got four kids, which isn't necessarily relaxing but definitely occupies his free time.

Show Links:

Herding Code 204: Sara J. Chipps and George Stocker on Jewelbots Jun 01, 2015

Show notes

Episode 204

The guys talk to Sara J. Chipps and Geroge Stocker about Jewelbots: smart jewelry for a smarter generation.

Note: They were called Jewliebots when the podcast was recorded, but were since renamed to Jewelbots.

Download / Listen: Herding Code 204: Sara Chipps and George Stocker on Jewelbots

Show Notes:

Hello There

(00:55) Sara and George introduce themselves and how they got involved in Jewelbots.

Jewelbot Features and Platform

(02:12) K Scott asks what Jewelbots is all about. Jewelbots are programable wearables for teenage girls. They're friendship bracelets that help them learn how to code. K Scott remarks that they're not just wearables that track the number of steps taken each day, and Sara says from their interviews, teenage girls couldn't care less about that. Out of the box, they have communication and friendship features, but they're open source so they can be extended to do things like let them know when they have a new Instagram follower or when their mom is on the way. There will be code snippets available to allow them to get started by copy / paste, then to share code they've writing. There will be a repository on GitHub for sharing and collaboration.
(05:06) K Scott asks how they decided on this platform. Sara talks about how they were inspired by Minecraft, and how they saw young people learning Java so they could write their own mods. They talked to over 100 girls, and learned that some of their initial assumptions were horribly wrong.
(05:55) Jon asks what was horribly wrong about their assumptions, and Sara says that just having jewelry change color to match their clothes wasn't that exciting to them - they're really interested in their friends and friend groups. You configure them to react to your friends and friend groups.

Hardware Specifics

(08:00) Kevin asks what it's like from a coding perspective. Sara says it's based on Arduino, so you can use the Arduino library on the bracelet to control the Bluetooth, microprocessor, LEDs and motor. George says the code for the predefined APIs will be available so girls can consult the existing code to see how things were built.
(08:50) K Scott asks if Bluetooth is used to detect nearby friends. Sara explains that it's a mesh Bluetooth network (something they've patented) that allows the bracelets to work without requiring their phones with them.
(09:15) Scott asks why they didn't use RFID instead of Bluetooth. Sara explains that RFID only works for a few inches, whereas Bluetooth gives them 30 to 50 feed.
(10:10) Jon asks if it's possible to extend the software, or to connect other devices via Bluetooth.
(11:22) Sara explains that the actual hardware is in a small disk, so it is possible that it could be applied to other use cases.
(12:25) K Scott asks what was the hardest part about developing it. Sara explains that hardware is so much more difficult than software, and how it's so much harder to change things later.
(13:28) Jon asks about the power and battery life. Sara explains the bracelet stand that can charge via USB charger and says they're still figuring out the battery life.
(14:32) Scott says they should build in kinetic charging and and asks about adding in sensors. Sara says that for size and cost constraints they decided to leave out sensors.
(15:35) Scott asks if they're 3D printing them themselves, or working with sweatshops in New Jersey. Sara says they're working with PCH and will be manufacturing in China for production, but they're currently working with local manufacturers for small runs.
(16:54) Jon asks what hardware is onboard. Sara runs down the list: a microprocessor / Bluetooth unit that's 4mm square, a motor, 4 LEDs, and a button and a battery. George says that the button can be used for a lot of things, including morse code or other codes they come up with.

Cost, Funding and Kickstarter

(18:59) Jon asks how much they'll cost. Sara says they're shooting for $60 but it will vary based on a lot of factors. They targeted $60 as it's the cost of a video game.
(19:58) Scott has another product suggestion: a backpack locator that shows hot / cold on the LEDs.
(20:19) Kevin asks about how they got started from a funding perspective. Sara talks about the funding history and hardware projects are more costly.
(21:26) Jon says Jewelbots sounds like something he'd see on Kickstarter. Sara says that they're planning to launch a Kickstarter soon, but they want to get the Jewelbot cost figured out first. There's the obligatory discussion of Kickstarter successes and failures. Scott says that the companies that already have their production pipeline figured out before launching are a lot more successful than vague "I have a dream" Kickstarters. Sara says they've also heard that you really need to have your costs figured out before launching a Kickstarter.

The First Rule of Introducing Girls To Coding: Don't Call It Coding

(24:50) Kevin asks if there are concerns that the Arduino IDE may be too low level, and if they might make an easier onramp. Sara says they don't think they'll convert every young girl into a coder, but they'll help a lot of them to look at code in a way they haven't before. One important thing they've learned is not to call it coding as that scares a lot of people off. Sara says that the opposite of maker is not girly - they want to make being a maker accessible. So if a small percentage actually become coders but the rest just become more comfortable with the idea of coding and engineering, they'll have accomplished their goal. Sara talks about Super Awesome Sylvia - a 13 year old girl who does all kinds of cool things with Arduinos.

Getting Started With Hardware... And Just How Hard Is Hardware, Anyway?

(27:22) Kevin asks how Sara made the jump from software to hardware. Sara talks about her introduction by Emily Rose (@nexxylove) at Node Dublin 2012 with a bullfighting drone and an out of control fog machine, and she was hooked on the spot. She started with getting LEDs to light up - the hardware equivalent of Hello World - and went from there.
(29:30) Scott talks about how much more you have to think about with hardware as compared to software, and how it's probably a good exercise for software developers to think differently about how they write their code. George talks about how he's new to hardware, and how power drain and battery life concerns made them think about things like haptic motor startup and different power consumption for different color LEDs.

Important Questions In Random Order, e.g. Charging, Release Date, the Phone App, and Piglets

(31:43) Jon asks for more info on the charging connection. Sara explains the 4 touchpoints on the charger which are used to both charge the bracelet and upload code to the device. Scott asks if they considered using Bluetooth; Sara says that they had and the Bluetooth chip allows for that, but since many of their target users use desktops they didn't want to require Bluetooth for data transfer.
(32:40) Jon asks if they're continuing to do user testing. Sara says that they're doing that constantly, and it's been really important.
(33:45) Kevin asks how soon they'll be shipping, and Sara says hoping to ship by late 2015 / early 2016.
(34:24) Jon asks if they're experimenting different charm designs with 3D printing. Sara says they're using injeciton molding for the charms, and that Jewelbots will ship with a default charm and band but they're interchangeable so they're expecting and encouraging people to make them their own.
(35:35) George talks about the phone app which allows for more of an if-this-then-that style of programming, which will be simpler.
(36:32) There's a question on twitter about Sara's thoughts on piglets.
(37:27) Jon asks for more details about the phone app. George says it's an Android and iOS app that allows you to add new friends and set up how your Jewelbot should react if you're around different friend groups. He explains a bit more about how things are stored on the bracelet, the phone app, and a central web server.
(39:14) K Scott asks how devices are identified so you can select your friends. George says you'll identify yourself when you set up the device and standard Bluetooth pairing handles connections. He talks about how some of the Bluetooth things they're doing use new parts of the BLE spec that nobody's done yet, so they're figuring things out.
(40:18) Jon asks if it's possible to do firmware updates. Sara says that the Bluetooth chip they're using allows for over the air updates, so they can distribute firmware updates to all devices from Jewelbot Central. George talks about the complications in the hardware world you don't think about in the software world - for instance, someone can decide not to take a firmware update, so you have to make sure things still work even if they don't take firmware updates.
(41:20) Sara says that Jewelbots will not help parents find their daughters. You'll need to manage that yourself.

Important Things You Should Click On

(41:43) Sara talks about the upcoming Kickstarter as well as the (now available) Quire campaign so you can be part of their growth and part of their company.

Show Links:

Jewelbots (jewelbots.com, @jewelbots)
Jewelbots campaign on Quire: https://quire.com/c/jewelbots
Sara J. Chipps (sarajchipps.com, @sarajchipps)
George Stocker (georgestocker.com, @gortok)
Super Awesome Sylvia (sylviashow.com)

Herding Code 203: Rob Eisenberg on Aurelia Apr 08, 2015

Show notes

Episode 203

The guys talk to Rob Eisenberg about Aurelia.

Download / Listen: Herding Code 203: Rob Eisenberg on Aurelia

Show Notes:

[Sponsor Message]
- (00:17) This episode is brought to you by the App Quality Bundle at http://buildbetter.software
Hello There
- (01:15) Kevin introduces Rob.
- (02:05) Kevin asks Rob about his Xaml platform work with Caliburn.Micro. Rob says he's transferred that work to Nigel Sampson, and it's alive and well.
Comparing Aurelia with Angular
- (03:22) Kevin mentions Rob's history on the Angular team and asks what's different about Aurelia. Rob says that he's focused on vanilla Javascript code and minimizing configuration and metadata. Rob says that's unique compared to most common frameworks, not just Angular.
- (05:25) Rob also wanted to target transpiled languages so it worked well with ES6, ES5, TypeScript and Coffeescript. By comparison, Angular was pretty focused on Dart and AtScript.
- (06:12) Jon references Rob's post comparing Angular and Aurelia code and asks about conventions. Rob describes how conventions work, how you can create your own conventions, and how you can override conventions by providing metadata (but only for overrides, not all the time).
- (08:56) Rob describes how binding and the templating syntax work. Aurelia minimizes additional markup for binding, whereas he sees Angular syntax focused on theoretical tooling experiences that could be built, but nobody's committed to. Also, while Angular's syntax is technically valid, it doesn't work with cases like SVG. There's a secondary binding syntax to work around that, but having two syntax doesn't seem like a clean solution.
- (12:31) Kevin asks for examples of conventions in Aurelia. Rob explains how custom elements work with EcmaScript 6 modules and exports. No metadata is required, as compared to Angular which requires specifying metadata in all cases even if you're not using them. Rob also explains custom attributes (again using a simple exported class). Naming conventions set up the mappings so no metadata is required. Value converters are yet another example - the naming convention assumes that any class ending in ValueConverter is automatically registered and configured.
- (16:24) Jon asks if Angular's metadata requirements and verbosity are all for tooling support. Rob says yes for the HTML side, he doesn't see a reason for it on the JavaScript side.
- (16:43) Rob says that in Angular you need to declare all directives you're using in your view models. That really bugs Rob because the implementation details in the view shouldn't be reflected in the viewmodel. That was required for lazy loading, but he sees it as a design problem and a maintenance problem. Rob says that Aurelia uses an import in the view and doesn't touch the viewmodel, using the EcmaScript 6 loader. Rob says that this design makes some conventions impossible.
The Aurelia Pitch
- (21:08) Scott K says he likes the class-based design in Aurelia and asks Rob for a quick pitch for Aurelia to sell it to a team. Rob talks about the clean, standards based design that allows decomposing complex screens without requiring extra configuration. It's easy to build, extend and maintain. Rob also talks about the binding syntax, and the ability to plug in other binding strategies by dropping in an adapter. The binding strategy system has been tested out with Breeze.js and Knockout, allowing you to use your existing models without requiring unnecessary dirty checks.
- (26:42) Scott K asks how object.observe works with tranpilers. Rob says there's a polyfill that generates getter / setter pairs if object.observe isn't available. Rob explains how this works with the micro task queue, and how it allows for queued tasks to handle queued work efficiently. Rob talks about the task-queue in Aurelia, and how it can be used outside of Aurelia as well. Rather than directly observing DOM elements, the task queue allows for batching changes for efficiency.
Persistance
- (35:15) Kevin asks if Aurelia handles a persistence layer. Rob says that rather than building that, they've worked to make it easy to plug popular persistence libraries in. He also discusses the validation system they're working on.
- (38:22) Jon asks if Rob's looked at PouchDb and references Herding Code 181, in which Max Thayer explained PouchDb.
Why not write my own framework?
- (39:40) Jon says he frequently hears people who are tired of JavaScript frameworks and decide to just write their own. Rob describes how it's easy to get started but quickly falls apart. He describes some of the gotchas he's run into in building Aurelia, with examples from aria, svg, data- attributes. Rather than writing your own framework, Rob says you should just contribute to Aurelia.
SVG use
- (44:40) Jon asks if Rob thinks people will use SVG. Rob says it's more about building a production-quality framework, then gives some possible usecases like graphs, mapping and custom elements. Rob says that people do all kinds of things you might not expect when they use a framework, and building a real framework requires it. Kevin says at his last job they'd started converting image sprites to SVG, and it was a pretty good use-case.
React
- (49:05) Kevin asks about Rob's thoughts on React. He says it's a good renderer, but it's not a framework. He and Scott K agree that React is a library, not a framework. Rob says he wrote a blog post in which a custom Aurelia element uses React as a custom renderer. The Babel transpiler allows mixing JSX with ES6 code, and this allows continuing to use Aurelia binding. In general, Rob says really smart, but if you need a framework you'll end up cobbling a bunch of things together to use it. Instead, he'd recommend using a framework like Aurelia and just pulling in React when it's required.
- (53:22) Kevin asks if Rob's considered adding a virtual DOM to Aurelia. Rob says it's not clear that there would be an advantage in most cases.
Isomorphic rendering
- (54:17) Kevin brings up the other JavaScript buzzword of the day: Isomorphic rendering. Rob says Aurelia doesn't support this, he doesn't see this sticking around. Jon says he still sees a pretty clear distinction between websites and web apps, and Rob agrees, saying he wouldn't use Aurelia for websites.
Questions from Twitter
- (57:25) Question from Twitter (@cecilphillip): "What's the rendering perf like compared to ReactJS?" Rob says that React is going to be a lot faster for initial render time, whereas Aurelia is probably going to be faster for updates. It's hard to give an accurate comparison; Rob says they're mostly focused on being fast enough rather than the fastest. He says Aurelia's not slow now, but they're focusing on some upcoming performance enhancements that he's expecting big results from.
- (1:02:09) Question from Twitter (@csharpfritz): "can you talk about what lead to the choice of architecture with JSPM?" Rob explains how JSPM integrates package management with module loading. Aurelia isn't directly dependent on JSPM, so you can use other package managers and loaders if you want. Jon says the one thing he wants JSPM to integrate rate limiting so he doesn't hit the GitHub rate limit; Rob says this is being addressed in a future release since most cases don't require the hitting the rate limited API.
Scott K's Packaging Rant(tm)
- (1:08:11) Scott K has a "short rant" about NPM, JSPM and all package managers in general: they all use existing config files (like gitconfig) and should be tested behind corporate firewalls and proxies. And then there's the nested package thing, which doesn't work well on Windows due to path length limits. Jon says he uses the flatten-packages package. There's a short group rant about the file path length limit on Windows.
Final questions and wrapup
- (1:13:40) Jon asks if there are any patterns or thoughts on server-side development for Aurelia. Rob says there are starter kits on the way, and people are using Aurelia with lots of back ends (.NET, node, MEAN, etc.). He talks about samples on the way, including a Todo app (even though he thinks Todo apps aren't useful for application frameworks).
- (1:17:15) Kevin asks where Aurelia's at in a release cycle. Rob says it's currently in preview / alpha phase but targeting a beta around June or later. Don't go to production with it now, but get ready for the release after that.

Show Links:

Herding Code 202: Ahmet Alp Balkan on Docker Mar 11, 2015

Show notes

Episode 202

The guys talk to Ahmet Alp Balkan about Docker, containers, building an ASP.NET 5 image for Docker, and working on the Azure Linux team at Microsoft.

Download / Listen: Herding Code 202: Ahmet Alp Balkan on Docker

Show Notes:

Working on the Azure Linux team at Microsoft
- (00:17) Jon introduces Ahmet and asks what it's like being on the Azure Linux team at Microsoft. Ahmet explains what his team does. Ahmet's mostly a Unix stack developer, he doesn't use Windows on a daily basis.
- (02:20) Jon asks Ahmet if it's strange working on open source and Linux and Microsoft, and if there are a lot of legal requirements.
Intro to Docker
- (03:48) Jon asks Ahmet to describe how Docker works, and how it compares to traditional virtual machines.
- (05:54) Jon asks about how the Docker works with the Linux filesystem approach. Ahmet explains namespaces in Linux and describes how namespaces provide separation between instances. One benefit is that each instance is really lightweight, so you can have hundreds of instances on one physical machine.
- (09:47) K. Scott asks about a specific example deploying a Ruby on Rails application. Ahmet describes two options for creating a creating an image - either doing it manually or using a dockerfile. K Scott and Ahmet discuss inheritance chains for containers.
- (13:35) Kevin asks about how inheritance works when you've got an application that relies on services in different parent containers - is there communication between them? Ahmet describes how the application files are based on diffs from each container level. Rather than modifying a running container, you should instead define and deploy a new instance.
- (17:07) K. Scott asks how different configuration between machines is handled.
Docker on Windows
- (18:13) K. Scott wonders how containers will work on Windows due to the registry. Ahmet talks about how it's more difficult on Windows, since on Unix everything is a file; Jon remembers the previous interview with Kenji at Spoon about how they're virtualizing the registry with their container system.
- (20:40) Jon points out that since Docker images run on top of a host, they're not portable between different hosts on different operating systems.
ASP.NET 5 Docker image and User Mode sandboxing questions
- (21:21) Jon asks Ahmet about his work on creating an ASP.NET 5 Docker image.
- (23:10) Scott K. asks about the difference between Docker images and running in user mode. Ahmet explains that Docker does run in user mode, so things are kept separate due to user mode sandboxing.
- (25:14) Kevin asks if the host operating system has visibility to the running containers.
- (26:12) K. Scott asks if there were any technical hurdles in creating the ASP.NET 5 Docker image. Ahmet talks about how the image was built and the general process of developing with Docker instances.
Getting started with Docker on Windows
- (30:15) Jon asks about different ways of getting started with Docker - Boot2Docker (running on top of VirtualBox), spinning up a Docker instance on Azure, etc.
- (31:54) Jon asks about Ahmet's work on getting the Docker client on Windows. Ahmet talks about some of the differences in Windows operating system API's, including Go language differences.
- (36:00) Scott K. says he's excited about Docker because it sounds a lot simpler than some of the deployment issues he deals with.
Docker in production and container orchestration
- (37:17) Kevin says he's heard that running Docker in production is more difficult than running it in development. Ahmet talks about some of the orchestration efforts that are underway, and talks about container linking and the datacenter operating system approach.
- (43:14) Jon asks about Mesos. Ahmet describes what Mesosphere is doing and how it relates to orchestration.
- (44:50) Jon asks if Azure orchestration will be similar. Ahmet says they want to play really well with the other schedulers out there.

Show Links:

Ahmet Alp Balkan (@ahmetalpbalkan, https://ahmetalpbalkan.com/)
Docker
Creating an ASP.NET vNext Docker Container using Mono
ASP.NET 5 Preview Docker Image
Docker CLI for Windows Clients

Herding Code 201: Kenji Obata on Spoon, application virtualization, containers, and flying little airplanes Dec 23, 2014

Show notes

Episode 201

Jon meets Kenji and Trevor at a small airfield in San Diego to talk about Spoon, an application containierization and streaming platform for Windows. They discuss different virtual machine approaches, Spoon's features, the container movement, and flying airplanes.

Download / Listen: Herding Code 201: Kenji Obata on Spoon, application virtualization, containers, and flying little airplanes

Show Notes:

Application virtualization and Xenocode's origins

(00:17) Jon says hi to Kenji and describes his first interaction with Kenji - a blog post he wrote in 2007 titled "We should be virtualizing Applications, not Machines" and Kenji's response saying that's exactly what they were doing at Xenocode. Kenji describes application virtualization and lists some of the vendors working in that space.
(1:51) Jon asks about the spectrum of virtualization - starting with virtualizing the entire machine and file system and dialing back. Kenji describes how Xenocode started with a solution that would allow for deploying .NET applications without requiring a separate .NET framework installation. This had minimal virtualization - just enough to virtualize the .NET framework.
(06:07) Kenji describes the work to move from virtualizing the .NET framework to supporting application virtualization for any arbitrary Windows application, culminating with virtualizing Office.

Moving from application virtualization to application streaming

(08:24) After solving virtualization for any Windows application, Xenocode moved on to tackling application delivery - solving long downloads, installation, and application conflicts. They also wanted to do this all over the web, which was the genesis of Spoon. This had a lot of appeal to business users rather than just coders, so they rebranded from Xenocode to Spoon.
(11:15) Jon asks about application streaming with the example of Office Click-to-Run. Kenji discusses Click Once and how that relates to MSI installers. While some application streaming solutions solve the problem of "click button, run application" they are still installing on the computer so you hit problems with conflicts between applications.
(13:20) Spoon applications are portable because they're not installed on the local machine. Kenji and Jon discuss how installing an using an application start changing the state of the machine in many places outside of the application directory - registry, user profile, etc.
(14:30) Kenji describes how many of their enterprise customers have complex legacy applications which blend several technologies and don't always follow best practices.

Docker and containers

(15:35) Kenji talks about how they've grown from looking at the smaller, targeted problem of virtualizing and deploying a single application to a holistic view of containers as a fundamental part of the development and deployment process.
(16:30) Kenji says that the excitement around Docker has got the community thinking more about application virtualization. Jon asks Kenji to explain how Docker-style virtualization is different from traditional virtual machine virtualization. Kenji explains how Docker was originally built on Linux lxc in which the kernel can segregate itself into several namespaces. Jon asks how it relates to file system virtualization, and Kenji says that since in Linux there's an "everything is a file" philosophy, it's easier to segregate things this way.
(18:10) Kenji says that there's really no virtualization engine in Docker, it's more of a set of scripting languages around Linux features. Kenji says that perhaps Docker's biggest contribution is the term "container" since it's more consumer-friendly and makes it more obvious that containerized applications are portable.
(19:55) Jon says that his experience with Spoon is that it felt like git for virtual machines. Kenji says that Docker actually uses git for storage. He explains how the storage needs of application virtualization lend themselves to git-like storage.
(21:44) Kenji says that containers on Windows are more difficult because there isn't an lxc feature in the kernel. Fortunately, Spoon already has a vm engine that can provide that.

Advantages to running in user mode

(22:12) Kenji mentions that Spoon is running in user mode rather than kernel mode, and explains why it's important to segregate and run child systems in user mode without any need for kernel access. Users don't need any special privileges to install Spoon applications, and even if there are security issue in the virtualized applications, they're always just running as an unprivileged user the host operating system.

Getting started with Spoon

(24:10) Jon talks about the user experience on Spoon.net - quick install with no permission prompts, and a console window pops up.
(25:24) Kenji points out that because Spoon started with virtualizing desktop applications, the Spoon container approach works well with any Windows application, including GUI applications.

Virtual networking features

(26:12) Jon asks how he can add add to a Spoon VM once he's created it. Kenji points out one approach by spinning up another VM and connecting them using Spoon's virtualized network feature. He talks about how you can use the virtual network features to point your application with multiple VM's all using virtualized networking and the virtual DNS service.
(29:20) Jon talks about how virtual networking on other systems like Hyper-V can be problematic because it's messing with the host operating system's network adapters and networking configuration.

Spinning up multi-VM environments

(30:28) Jon says that all of these features sound really useful for testing, because he can spin up an entire environment, test it all, and delete it, all from a script. Kenji says they've put a lot of focus into those scenarios, and since Spoon VM's are so lightweight that you can spin up 20 or 30 VM's on a dev machine. He talks about a customer that has about 20 servers in their test environment and spins them all up for tests on a single host.

Selenium support and legacy Windows features

(32:42) Kenji says they have first class Selenium test grid support, allowing web developers to run automated web tests against a wide variety of operating systems and browsers. Jon asks how this works IE versions are tied to versions of Windows. Kenji talks about the Windows version support they've built into Spoon, allowing a Spoon host on Windows 8 to run every IE version back to IE6.
(34:37) Kenji talks about Windows version support and stacks and conditional layer support in Spoon to allow wiring in complex emulation behavior so you can deliver one image that will run on a variety of Windows hosts.

Working with images and state

(35:44) Jon asks about how the "spoon run dotnet,jdk,node,nginx" support works, and Kenji says you can use that to compose an arbitrary number of base images.
(36:36) Kenji says that they heard a lot of customers were bringing in git support to build a project that's hosted in git, but they didn't really want it in the image. They added another "using" primitive to allow you to use support from an image without adding it to the base VM.
(37:53) Jon asks how to add features to the Spoon VM after it's been created, in the case that he really does want them there. Kenji says that I can just save the container's state as an image, then build another container on top of that image. Images are static, containers are not.
(39:01) Kenji talks about the state abstraction, allowing you to continue from any saved state id. These move between different computers, which is helpful for testing and parallelization.

The Spoon.net hub and what you can do for free

(41:00) Kenji mentions the Spoon.net hub, which is free to use for public use - similar to GitHub. Jon asks about what's available for free use, and Kenji says Spoon.net use is unlimited (within reason).
(42:01) Kenji explains how their previous version required their Spoon Studio tool to configure applications, similar to App-V sequencing. Things are simplified now with Spoon - you just grab a clean image, install software on it using the standard installers, and commit the image and you're done.
(44:04) Kenji highlights the advantage of having the clean image readily available, so you can easily get a clean Windows install to try or test software - just by typing "spoon run clean".

Trying things with "spoon try"

(45:13) Jon says he likes to use VM's to get a clean machine state, and also to be try installing some software without risk. Kenji talks about the "spoon try" command, and explains how try automatically wipes all your state when you're done (whereas spoon run maintains state).

Deployment options

(47:38) Jon asks how IT managers roll out Spoon solutions to their users. Kenji says they provide a set of tools to integrate with existing deployment models, including support for desktop icon registration, scripting, and the web interface to allow launching from intranets.

Size and performance impact

(49:00) Jon asks about the size of a Spoon VM. Kenji says it's essentially just the size of the installed software and the state, so it's pretty minimal. Storage is delta-based, so it's small. The Spoon database includes de-duplication to allow for frequently saving state without bloat.
(51:01) Jon asks about the performance impact due to virtualizing everything. Kenji says that since the VM's are so lightweight, it's very minimal. He gives examples of high-performance users, including AutoCAD and video game developers.

Azure RemoteApp support

(52:29) Jon asks Kenji about something he saw on the site mentioning that Azure support was coming soon. Kenji gives us an exclusive scoop on the upcoming RemoteApp support. This allows you to create a single base VHD on Azure with just Spoon installed on it, then use Spoon's support to host any application via RemoteApp. He says it's great to be able to use RemoteApp support when he's on his Mac to run any Windows applications he needs.
(56:53) Jon recommends for listeners to go to Spoon.net and try it in a few seconds for free.

Flying little airplanes

(57:21) Jon notes that they're recording the podcast at an airfield and asks Kenji and Trevor about how they got into flying. Jon notes how high-tech the plane controls are and asks how it compares to Microsoft Flight Simulator. Kenji talks about the excitement and terror of his first takeoff.
(1:01:29) Kenji says that an easy way to give flying a try is to contact a flight school at your local airfield and set up an introductory flight for about $100 - $150 to give it a try.

Show Links:

Spoon.net (@spoonapps)
Kenji Obata (http://kenj.io, @virtualkenji)
Jon's post: We should be virtualizing Applications, not Machines
Joel Spolsky: Please Sir May I Have a Linker
Ship Your Apps to Azure RemoteApp with Containers

Herding Code 200: io.js, Angular angst, K Scott's new Band, Kickstarters, Containers and Old School Elite Women Coders Dec 20, 2014

Show notes

Episode 200

The guys talk about the Node / iojs fork, Angular 2, K Scott's new Microsoft Band and other wearables, Kickstarter successes and failures, container technologies like Docker, and some recent articles about women heroes of coding.

Download / Listen: Herding Code 200: io.js, Angular angst, K Scott's new Band, Kickstarters, Containers and Old School Elite Women Coders

Show Notes:

The Node / io.js fork
- (00:41) Jon asks Kevin what's going on with the io.js fork. Kevin says the fork is due to the Node team's slow release cycle. Jon asks what technical things people are looking for, and whether io.js code is supposed to be compatible with Node code. Scott K lists some of the features planned for Node 0.12. There's some general discussion about what this means long-term and whether this will be a temporary or permanent fork.
Angular angst
- (06:21) Jon asks K Scott what is going on in the Angular world. K Scott summarizes why people were bent out of shape over the Angular 2 announcements.
- (07:30) Jon asks what this all means from Angular developers - what's actually changed? K Scott discusses how the team isn't worrying about migration from Angular 1.x. He mentions AtScript and the guys discuss how it relates to TypeScript. Kevin asks if Google is the new Microsoft, in that everything has to be their way. K Scott says it's feeling like MEF composition.
- (12:09) Scott K says he thinks the radical changes are to support components and dart. K Scott says he also sees that runtime introspection looks like an important goal.
- (13:30) Scott K talks about the migration plans and the announcements that 1.x won't be getting any new features. Kevin says this puts Angular developers in a tough spot, because 2.0 isn't going to be out for a while and 1.3 is the final release in that branch. Scott K says he's stopped paying much attention to it for now while waiting for things to shake out. There's a discussion of Durandal now that Rob's left the Angular project.
Wearables and the Microsoft Band
- (17:30) Jon asks K Scott about his new Microsoft Band. K Scott says he likes the notifications and sleep notifications. Jon asks if the sleep notifications are actionable or just telling you things you already know; K Scott says he's notices that poor sleep for three nights in a row affect his communication skills.
- (20:25) Jon says he hasn't been able to pull the trigger on Pebble, even on super sale, but the Band looks really interesting. The voice input for Cortana looks neat, too.
Windows Phone interlude
- (21:55) K Scott says he helped a friend pick out a Windows Phone and was impressed by the inexpensive models from Blu. Jon talks about how all the new Windows Phone models are nice inexpensive phones rather than flagship models. Jon mentions the app coverage and says that all the big apps seem to be available, the only ones he misses is an app from his bank to deposit checks.
- (24:30) Kevin says it seems like Windows Phone is swimming upstream on apps, mentioning recent articles from Tom Warren and Ed Bott.
Wrap up on wearables
- (25:55) Jon asks Kevin what he's thinking on the Apple Watch. He says he's intrigued and wants to play with one to see.
- (26:55) Scott K says there's not much you can really do on a tiny screen, so consuming content on a watch is silly. Jon says that he sees room for things like two-way communication and remotely controlling the desktop. Scott K says his Pebble is kind of like a second screen for his phone. He says there isn't enough horsepower on a watch for voice recognition, but the other guys all jump in to say that the watches use Bluetooth to work with the voice recognition on their phones and it all works pretty well.
Kickstarter
- (32:15) Jon says he's backed ten projects, but only three of them really turned out well: gourmet marshmallows, a web-based font creation program called Prototypo, and a file manager called OneCommander. Scott's had good success because he does some due diligence on the shipping background for the creators.
- (35:15) Scott says he avoids tech projects on Kickstarter because he knows geeks, and he knows the overestimate what they can do: they all think they're physicists, nutritionists, lawyers... they think they know everything, and they don't anticipate the cost and effort to go from prototype to shipping product. Jon says he's seen two software projects that were flawlessly executed - BitCommander (since renamed to OneCommander) and Prototypo. In both cases the creators were very communicative throughout the project.
- (39:55) Kevin's never Kickstarted anything because he doesn't want more things. Jon says he usually backs things because he wants to support someone doing something cool, not because he wants a project. He says he frequently sees popular new technology Kickstarters that are recreating something he can find already shipping on Amazon for a lot less. Kevin says he finds the whole Kickstarter thing is completely fascinating, and he's amazed that it seems to work. Scott K talks about how many game manufacturers use it to figure out how many to produce rather than to start figuring out how to produce a project. Jon mentions a Sony epaper watch that was Kickstarted just to gage interest and says that the goal of Kickstarter is to actually graduate to shipping product and lists a few; Kevin talks about the Veronica Mars movie.
Containers
- (47:20) Jon talks about Docker and Rocket and asks if the guys are using them yet. Kevin says that poor OSX support (requiring VirtualBox Boot2Docker) has cooled the interest in Docker in his shop.
- (48:55) Jon says he thinks the container approach seems like a nice middle ground between running a native process and a full virtual machine. He says that he'd like to talk to the Spoon team soon to hear about their Windows native container system.
- (51:15) Scott K talks about the Mesos system - a distributed systems kernel. Jon searches around and finds it's an Apache project. The idea is that you can move your Linux applications over to it, then scale across commodity hardware. Jon worries about the latency but figures eventually you overcome latency with processing power if it's distributed right.
Women In Computers, Old
- (55:05) Scott mentions an article about Margaret Hamilton, the software engineer who wrote the code for the Apollo Eleven and came up with the term hardware engineer. Scott says that the Apollo source code is up on Google Code.
- (56:45 )Jon talks about an article he saw about the programmers who wrote code for the Colossus in World War Two, and they were all women. Kevin says he saw an article about how until the early '80's the distribution was even until there was an advertising campaign that was geared to boys, and things changes after that.
- (58:20) Scott talks about an article he read about The Sotry of Mel, who was working so close to the metal that he optimized for where the memory would be located on the physical memory drum.

Show Links:

io.js
Rob Eisenberg: Leaving Angular
Prototypo
OneCommander
Tom Warren: I've given up on Windows Phone
Spoon
Mesos
Margaret Hamilton
Apollo source code
When Women Stopped Coding
The Story of Mel

Herding Code 199: Rob Reynolds on the Chocolatey Kickstarter, Chocolatey growth and OneGet Nov 08, 2014

Show notes

Episode 199

Jon talks to Rob Reynolds about how Chocolatey has grown over the past few years, how OneGet fits in, and the Chocolatey Kickstarter.

Download / Listen: Herding Code 199: Rob Reynolds on the Chocolatey Kickstarter, Chocolatey growth and OneGet

Show Notes:

The state of the Chocolatey
- (00:19) Rob explains what Chocolatey is and compares it to package managers on other platforms. Jon talks about how he uses Chocolatey to install all his programs every time he installs Windows.
- (02:10) Rob talks about how Chocolatey has grown in the past 3 1/2 years.
Package Moderation
- (02:24) Rob explains how package moderation works - whereas previously all packages were immediately published and reviewed later, now they're reviewed by moderators before they're listed. One common fix is just getting the naming right.
- (05:24) Rob talks about how they're curating the community feed. They're currently in a grace period until December 1; some packages are that aren't broadly applicable are being told to move to MyGet. Jon and Rob talk about other hosting options (anything that host NuGet) and benefits of using the NuGet infrastructure underneath Chocolatey.
- (07:25) Rob talks about the checksumming features they've added.
Chocolatey Pro
- (09:03) Rob explains how Chocolatey has grown, partly due to the OneGet announcement - they're up to 7 million downloads now, half of them in the past six months. He talks about how the costs have grown over that time.
- (11:40) Rob explains what the Kickstarter supports. The free / open source version will always be free. They're also adding in professional-only feeds and a content delivery network to support the professional feeds. Jon asks and Rob explains the professional feeds work.
- (14:50) Rob explains how the pro version includes additional virus checking via Virus Total.
- (15:31) Jon says it sounds like most of the money is to provide for infrastructure. Rob agrees, but says some will help buy him some time to work on it. He talks about the example of Octopus Deploy - development has really accelerated since it became a full-time endeavor.
OneGet
- (17:05) Jon asks what OneGet is. Rob explains that it's a package manager aggregator and works with the Chocolatey feed right out of the box. Rob and Jon talk about the advantages of having Chocolatey support installed in Windows.
- (20:20) Jon asks about the impact to the Chocolatey team. Rob clarifies that they're a provider, so they build the hooks, and OneGet will read directly from their feed.
Windows Store
- (21:02) Jon asks if Rob's worried that the Windows Store will someday add Win32 app support and make Chocolatey irrelevant. Rob says he doesn't expect it, but even if they did there are some big differences between a store and a package manager. Jon and Rob discuss package managers, meta-packages, dependency management and package uninstallation.
Kickstarter Benefits
- (24:36) Jon asks Rob to explain the different Kickstarter award levels. Rob discusses Chocolatey Pro pricing and some of the higher level awards like a custom workshop. He points out that the pricing is perpetual for business accounts, so by backing the Kickstarter you're locking in the price.
- (29:00) Jon says that even if you don't care about the rewards, if you've been using Chocolatey you should consider supporting the project. Rob describes why they came up with their goal amount, including the Kickstarter and Amazon transaction fees.
Wrap-up
- (21:29) Rob and Jon mention ways you can get involved. Of course you can back the Kickstarter, but he's also really appreciate any press or exposure.

Show Links:

Herding Code 198: Damian Edwards on ASP.NET vNext, Tag Helpers and SignalR Oct 14, 2014

Show notes

Episode 198

The guys talk to ASP.NET team member Damian Edwards about ASP.NET vNext (the next version of ASP.NET), Tag Helpers, and what's new with SignalR.

Download / Listen: Herding Code 198: Damian Edwards on ASP.NET vNext, Tag Helpers and SignalR

Show Notes:

Hello. What is ASP.NET vNext?

(00:18) ASP.NET vNext is the next version of ASP.NET. It's not just ASP.NET MVC 6 or Web API 3, it's a total rethink of the ASP.NET platform. In some ways, it's a bigger change than the move from classic ASP to ASP.NET. In other ways, it can be pretty seamless depending on what you're doing.
(01:29) Jon asks Damian to talk about what's crazy and brand new. Damian describes the full stack in a web application, from the operating system up to the code that you write in your application and the libraries you bring in. Starting at the bottom of the stack, ASP.NET vNext is cross platform, meaning it will work and be supported on Linux and Mac.

Cross platform

(02:36) Jon asks Damian to clarify what that means - is it supported cross-platform, or does it just kind of work? Damian says that it's first class support - they'll ensure that it works cross-platform, there will be cross-platform documentation, and there will be cross-platform tooling (Damian mentions the Sublime plugin for ASP.NET vNext). They'll support building and deploying ASP.NET vNext applications cross-platform.

Core CLR

(03:41) Damian continues up the stack, talking about how .NET framework is booted up. In vNext, there is a native code custom CLR loader that is decoupled form the operating system's .NET loader. Even when you're running on Windows, you're not relying on the standard .NET loading mechanism.
(05:56) Jon mentions having seen demos where code was written on one laptop, copied onto a USB drive, and executed on another laptop, asking if the custom .NET loader is what makes that work. Damian explains that's half of why it works - the next layer of the platform is the managed runtime itself, which is the other half of the magic. There is a new CLR based on core CLR. Damian explains how the .NET runtime runs on a core CLR and the base class libraries. The core CLR is based on the .NET CLR for Silverlight - it was already a lightweight version that ran cross-platform. There are now two options for the CLR you can run on - the full .NET CLR, or the new "cloud optimized" CLR. It's important because it's smaller - so small that it can be deployed with your application. Also, because it can be self-contained, multiple versions can run on the same server.
(10:01) Scott K asks what prevents bundling the entire application up into a single EXE. Damian talks about how .NET Native is being used in Windows Store applications and says they're intending to look at that for ASP.NET vNext in the future. For now they're achieving isolation by shipping the core CLR and libraries as NuGet dependencies.
(12:30) Scott K asks if you need to have the .NET framework installed at all if you're running ASP.NET vNext. Damian says no, and if .NET is installed it has no bearing on your application.
(12:12) Jon asks how this affects IT shops that want full control over .NET framework installations on their servers. Damian says this question requires more context on what administrators would be afraid of. He describes how ASP.NET vNext will support servicing, so any urgent vulnerabilities can be patched globally on a server.

How does this affect existing apps? What changes?

(14:50) K Scott brings up a Twitter question from James on how this will affect ASP.NET MVC and Web API applications. Damian says that ASP.NET MVC 6 will include both ASP.NET MVC and Web API. Damian explains how ASP.NET MVC is on version 5 and there are some things they'd do differently today. It also previously depended on System.Web, which dates all the way back to before 2000. ASP.NET MVC 6 has DI built in. It's OWIN compatible, so you can run it on any OWIN compatible server and run any OWIN middleware. Global configuration (web.config and System.Configuration) are gone, replaced by code-based configuration influenced by Katana. There's also Entity Framework 7, which is a complete rewrite that doesn't have ObjectContext or System.Entity - instead it makes model first (DbContext) foundational. EF7 also works with non-relational databases. If you have an existing application with ASP.NET MVC 5 or Web API 2, it should port over pretty seamlessly as long as you're not working directly with underlying components like System.Web or HttpContext.

Development experience

(19:39) Scott K asks about the development experience - will this work in a new Visual Studio version, or can he just create applications in a text editor? Damian says both will work. This both allows cross-platform development and a more flexible development stack, allowing for things like cloud-based development. Of course, ASP.NET will work work great on Visual Studio. They use Roslyn to do all the code compilation either at design or compile time. This allows for deploying the entire application as source, and eliminates the need for a separate compile step during development (since the code is constantly being compiled as you work).
(25:15) K Scott asks how much churn he should expect if he starts developing with ASP.NET vNext today. Damian says there's a lot of churn still right now. It won't release until well into next year some time.

Questions from Twitter

(26:34) Iris Classon asks what features they weren't able to include that they'd have liked to. Damian says it's too early to answer that question, since they're still in pretty early development.
(27:00) Iris Classon also asks where they looked for inspiration. Damian mentions web frameworks like Rails and Node as well as module loading in Java.
(27:38) Ben Maddox asks how Damian sees this improving the feedback loop for code, UI and tests. Damian says it speeds up UI feedback since all of your code is compiled as you type it and continuous testing is enabled due to the continuous compile. Both are available today with other tools or things you set up yourself, but it will be simpler in future.
(28:55) Steen R. asks when we'll see cross-platform Visual Studio. Damian says there are no plans he's privy to.
(29:05) Filip Woj. asks if F# will have first class support - released and supported. Damian says not for version one, although there are demonstrations of F# providers.
(30:40) Steen R. asks how webroot will work in practice. Damian describes how webroot works - it's a separate directory from which your application is served. Any files not in the webroot folder will not be served by the web server. Your application or uploads folders will be separate from your webroot, so they can't be served.

Portable areas?

(33:49) K Scott asks about portable areas. Damian says he's not aware of something like that for ASP.NET MVC.

Tag Helpers

(35:18) Jon asks what tag helpers are. Damian describes how Razor is a templating language that's designed to allow mixing C# and HTML. It falls down a bit when you're using HTML Helpers and want to change the output - for instance, if you want to pass in an HTML class to an element. C# gets in the way due to things like class being a reserved word, and you miss out on any HTML IntelliSense or HTML editor smarts, because you're just working with C# strings. Tag helpers allow you to just write HTML tags with attributes that Razor understands. These can do things like access the model metadata to emit appropriate form HTML.
(41:27) K Scott asks when he can start using it. Damian says that it's in a separate feature branch now and explains how to use them and says you can ping Taylor Mullen for help - or just wait a few weeks and it'll be in the main branch.
(42:59) Jon comments on how the Spark view engine provided something similar, and Damian says that Lou works right next to him and has helped with the design. They're not trying to change the core of how Razor works or feels, just make it easier to work with HTML helpers.

SignalR

(44:10) Jon asks what's new with SignalR. Damian runs down some of the recent releases and mentions SignalR 3 for ASP.NET vNext. He also mentions the C++ client that's currently in development.
(45:28) Jon asks if ASP.NET vNext makes some things simpler for SignalR. Damian says the main impact is that things like configuration and tracing are now shared between components like Web API and MVC.

Wrap Up
- (46:56) Jon asks Damian what's coming up for him. Damian mentions some of the talks he'll be doing at NDC London, including load testing SignalR and ASP.NET vNext.
- (47:50) Jon asks Damian how people can keep up with ASP.NET vNext, mentioning the asp.net/vnext page. Damian also recommends the weekly ASP.NET vNext Community Standup meetings, being run as a public weekly Google Hangout hosted by Scott Hanselman and Jon Galloway.

Show Links:

Herding Code 197: Summer Stories, C# 6, Vim and Atom, Terrible Keyboards, Poorly Aged Hipster Code, React and the Apple Watch Sep 29, 2014

Show notes

Episode 197

It's time for a discussion show!

Download / Listen: Herding Code 197 - Summer Stories, C# 6, Vim and Atom, Terrible Keyboards, Poorly Aged Hipster Code, React and the Apple Watch

Show Notes:

(01:22) What's new for Kevin? Node, Backbone, working at Brandcast, some talk about how the shop runs. Plus he's been busy moving.
(03:12) What's new for K Scott? Lots of JavaScript, C# / MVC, AngularJS, MongoDB. Jon asks how Mongo is working in production in the healthcare application K Scott had mentioned earlier. K Scott talks about some performance issues he's looked at, including some that came down to C# queries, and an issue with a 16MB document size limit. Jon asks if they're using Redis or other front end caching outside of Mongo. K Scott says they're just map-reducing and storing the information in other collections. He's not travelling quite as much
(06:50) Jon asks K Scott about his recent posts on C# 6 and EcmaScript 6. K Scott talks about looking into traceur to write current code today in ES6, compiling to ES5 to work in current browsers.
(07:25) Jon asks K Scott about his recent C# posts on property initializers and primary constructors. K Scott talks about those as well as the new "using static" feature to invoke static members without needing to use the type name.
(08:42) Scott K mentions a discussion about required properties with property initializers. K Scott says he was hesitant about a few things with the new syntax, and problem being that there's no initializer body for validation. You can mitigate that a little using an assert in a the initializer. It's nice not having to write explicit setters.
(11:06) Scott K says he doesn't even think about property syntax all that much because Resharper and CodeRush handle that for him. Jon speculates how long it will take for Resharper to start yelling at him to use primary constructors everywhere. Scott K says he uses CodeRush for that reason and turns off the code hints.
(12:27) K Scott asks what software Kevin is using: OSX and MacVim.
(12:40) Jon asks if anyone's using Atom.io. Scott K says he tried it and it was way too slow. Kevin says that after using Vim he has a hard time with heavy IDE's - even WebStorm. He's skeptical about the longevity of new code editors, while Vim is eternal. Jon says he's interested in Atom.io because it's cross-platform and open source.
(16:05) What's new for Jon? He's been doing some courses for Microsoft Virtual Academy - Introduction to ASP.NET MVC and a Bootstrap course including some advanced stuff like Bootstrap Mix-ins. Wrox Professional ASP.NET MVC book is out. He went to Norway for fun and went to pulpit rock. He's been spending some more time on non-Microsoft web stacks and platforms now that Azure and ASP.NET vNext are cross-platform. Scott K and Kevin talk about the fun of switching operating systems and remembering keyboard shortcuts. Jon says the biggest frustration is that he keeps trying to touch the screen on a MacBook and it doesn't do anything.
(21:30) What's New for Scott K? He got a new computer a Lenovo U530 - he calls it the consumer version of the Carbon. He talks about some of the confusing things about the Lenovo keyboard, especially the function keys. Everyone talks about function keys and keyboard problems. K Scott has a newer Carbon, and the keyboard is driving him nuts. Scott K says he's constantly hitting the touchpad because his keyboard is off-center, which always brings up the Windows charms. Jon mentions touchfreeze and other ways of disabling the touchpad while typing. Jon says he rarely uses the touchpad because he just uses the touchscreen. Scott says he never uses it, he thinks it's weird that you use two fingers to scroll on the touchpad and one on the screen. K Scott said he accidentally put his Carbon in caps lock, but he doesn't have a caps lock button so it was hard to turn off. Kevin is unhappy with the Microsoft Sculpt Keyboard's function keys. Everyone, please stop messing up the function keys.
(34:13) Jon asks if anyone's use the CODE keyboard. He and Jon both agree that it looks great, but they can't use non-ergo keyboards. Scott K wants keyboards to keep it simple and last a long time.
(35:27) Scott K get back to telling us about his summer activities. He was working on upgrading a MonoRail that drove him crazy due to being "craftstmanned up" with lots of opinions in the code like fluent extension methods, Brails view engines and difficulty in upgrading libraries due to dependency injection and breaking changes in NHibernate. Jon says that he's developed an aversion to things that make great blog posts but will be hard to work with in a few years. Scott K says 90% of the problems came from strong naming - binding redirects and ILMerge with aliases didn't help. They've been evaluating MongoDb and AngularJS a bit at work
(41:50) Scott K used React with Grunt in his MonoRail project to allow him to add client-side functionality into a frightening legacy application. Jon asks how he sets it up so it works at dev time and Scott K explains. Kevin's been hearing a lot about React lately. Scott K like that it's not trying to be MVC, just the V - e.g. no two-way binding - and the virtual DOM diffing is so fast that people are even using it with AngularJS and Ember just to speed up diffing large lists. Plus it's used by Facebook for Instagram and the commenting / messenging on Facebook, so it's been proven to work in big apps. He thinks it's going to be bigger than Angular and Ember in the next few years.
Lightning round
(46:34) Who's getting the new Apple Watch? Kevin says it seems iPad 1-ish. Jon likes some things about the watch UI, including the automatic answer prompts from instant messages with questions. He says the Moto 360 looks better, and we haven't heard anything about battery life. He's not sure what he'd do with today's smart watches, but hopes watches will be really cool in a few years. Jon doesn't like all the proprietary stuff - payment, chargers, etc. Scott K says he could easily switch to Android and it wouldn't bother him, so he's not going to be getting the new iPhone. He's got a Pebble and likes the notifications and battery life. He thinks the Apple Watch is too little too late. He thinks everything from Apple has gone downhill post-Jobs. He also talks about his recent laptop purchase - if he wanted a posix system, he'd rather just buy a laptop and put Linux on it. He starts ranting about npm and K Scott cuts him off. But then the guys start complaining about the live stream and things go off the rails again.
(1:02:32) Jon asks why nobody's moved to CouchDb. K Scott says the company behind MongoDb is pretty pushy. Nobody had looked at DocumentDb yet, and both Kevin and Scott K are bullish on Postgres.

Show Links:

Sponsor

This show is brought to you by Runscope - find out more at http://runscope.com/herdingcode

Our TOPPODCAST Picks

Follow Us

Stay Connected

Related Podcasts

Links

Stay Connected