Herding Code

This week on Herding Code, the guys talk with Microsoft MVP, MSDN Magazine columnist and Programming Entity Framework author Julie Lerman about what’s new in Entity Framework 4. 

  • The show begins with Julie providing a broad look at the new features and improvements around the EF designer, the run-time, POCO support and disconnected entities.
  • Julie talks about her world of database-first development and learning about persistence ignorance, repositories and domain driven development.
  • The group talks about the history of Entity Framework and how it is more than a typical ORM.
  • K Scott and Julie dive into the designer support for database-generated entities and starting with a blank slate for POCOs.  Julie notes that one can create the DDL in the Visual Studio designer and then generate the database from what is modeled.
  • The group talks about green field vs legacy database development and Jon comments on migrations and updating models.
  • Scott K asks about hurdles such as generated code being overwritten when using the designer. Julie speaks to updating the model from the database and using views rather than tables to generate the model.  Julie shares complications around foreign keys and RIA services and managing large models in the designer.
  • K Scott brings the talk back to POCOs and Julie discusses code generation templates customization with T4 templates. 
  • Jon mentions the Visual Studio Extension Manager and how adding template items from the online gallery is just so easy.
  • K Scott asks Julie about Code First development with EF 4 CTP4 and compares Code First to  Fluent NHibernate.
  • The conversation jumps between versioning, plain old PHP objects, ALT.NET kerfuffle and the Vote of No Confidence.
  • Julie and K Scott speak to the two types of POCO support, virtual properties, dynamic proxies, lazy loading and select n + 1.
  • Jon asks about EF’s context lifecycle management for ASP.NET and the complexity around disconnected entities.  Julie shares her recommendations on change tracking, entity state properties, self-tracking entities and persisting to the database.
  • Julie talks about her book, Programming Entity Framework, the rewrite for EF 4, her Data Points column in MSDN Magazine and the MSDN Development videos.
  • The show wraps with comments about Domain-Driven Design and the Norwegian Developers Conference talks.
  • Postscript – Jon calls Julie back to talk about the new CTP 4 release.
  • Julie talks about how some of the changes are specific to code-first, and others enhance to the core API in CTP 4 to facilitate use of code-first.
  • Julie describes the DbContext and DbSet, how they relate to ObjectContext and ObjectSet, and how they’re so much simpler to work with.
  • Julie then talks about how the code-first changes make it possible to remove a lot of code because the model is inferred, but you can override things using model builder code or attributes.
  • Jon and Julie talk about the Ugly Buddy class, which allow adding attributes to an EF model.
  • Julie talks about how the conventions have gotten a lot smarter.
  • We talk about Scott Guthrie’s post, and how he’s demonstrating how to take maximum use of the EF / Code First approach.
  • We wrap up by talking about improvements in how updates are handled. There’s support for a few workflows – manually keeping them in sync, having EF drop and create, and have EF drop / create / populate. However, as far as we can tell, this drop doesn’t include a migration system.

Show Links:

Show notes compiled by Ben Griswold. Thanks!

Download / Listen:

Herding Code 88: Julie Lerman on Entity Framework 4

Audio clip: Adobe Flash Player (version 9 or above) is required to play this audio clip. Download the latest version here. You also need to have JavaScript enabled in your browser.

This week on Herding Code, the guys talk with Jeff Atwood about his new Area 51 venture, the running of Stack Overflow, the community of Q & A sites, and memories of the glockenspiel.

  • Jeff walks us through the genesis of Stack Overflow and how it begot Server Fault, Super User, Stack Exchange and now Area 51.
  • Jeff explains Area 51 and the democratic process around establishing a knowledge-based site.  The guys talk about the old Stack Exchange pricing model and how Area 51’s approach is entirely different.
  • Kevin asks if there’s a concern that Area 51 will have a geek skew – especially since there’s likely a draw from the existing geek ghetto.
  • Scott K asks about bringing experts involvement into communities.  For example, including Alton Brown in a cooking site.
  • Jon and Jeff talk about the model of selling software and the magical wonderland that is Coding Horror.
  • Jeff talks about the Stack Overflow API and the Stack Exchange API Contest.  There are PRIZES!  The guys consider when an API is necessary and what APIs can provide.  Did somebody say community-built iPhone application for Stack Overflow? 
  • Jon asks if the Stack Overflow API will support OData.  Jeff answers “yes”, and then the conversation turns to talk of data analysis and the economics of Q & A sites. Jeff gets back to the OData, “the Sharepoint of sharing data on the web”, and points us to the OData web UI which queries current SO data dump.
  • Scott K notes that Stack Overflow is optimized for answerers and asks Jeff for his comments on the Stack Overflow Fatigue article.  Jeff talks about site popularity, community/user issues which don’t occur on smaller sites, and moderation tools.
  • Jon asks about expertise and tag-based badges and comments that reputation is self-correcting.  Jeff stresses that the site is really optimized for those who are the best communicators and not necessarily those who are most knowledgeable.
  • Kevin asks how Jeff responds to folks who have no chance of gaining enough critical mass to have their interests manifest into a Area 51 site.  Jeff shares his thoughts on community growth and launching and supporting sites with love. 
  • Jeff talks about open source, driving forward and evolving his sites and the problem with trying to be all things to all people.
  • Jeff fields Twitter questions about Stack Overflow SQL scalability, Stack Overflow’s testing and deployment story and how Jeff’s role has changed with the introduction of many new faces working on the app.  This triggers conversations about hosting on the Microsoft platform, the good and bad of Bizspark, the benefits of servers/hardware being cheap and general happiness with the stack.  Jeff also speaks to continuous integration and argues against unit testing all features.  Jeff speaks of the pointy-haired boss, Metcalfe’s Law, the quite guy problem and how to work with distributed teams.
  • The show wraps with Jeff sharing his dependence on human unit tests, cheating, optimizing for the “mistake fixing” and Stack Overflow’s loose web development process.

Show Links:

Show notes compiled by Ben Griswold. Thanks!

Download / Listen:

Herding Code 87: Jeff Atwood on Area 51 and Stack Overflow

Audio clip: Adobe Flash Player (version 9 or above) is required to play this audio clip. Download the latest version here. You also need to have JavaScript enabled in your browser.

While at Web Camps London, Jon talks to Saqib Shaikh about how he’s able to develop with limited sight and what developers can do to make our applications more accessible.

  • Saqib talks about his role on the Bing Team, data mining and deep links.
  • Jon and Saqib talk about solving problems with a little help from Twitter.
  • Saqib explains the function of a screen reader and how some people can listen to computers really fast.
  • Jon asks about common frustrations around accessibly when web browsing. Jon considers the tie-in between SEO and accessibility.  The guys dive a little deeper into structuring information, images vs text and learning the few basics.
  • Jon asks if there’s a way to do accessibility analysis? Saqib points to the “Check Accessibility.” option which is available when right-clicking on the web project in VS 2010.  (It’s there. I checked.)
  • Jon and Saqib talk about coding with limited sight. Saqib shares his general techniques.
  • The conversation continues with talk about Microsoft product development and the importance placed on accessibility.
  • The show wraps with Saqib introducing the term “Universal Design” of all things.  As a developer, you want to make your applications for the largest number of people to use. Just keep in mind that “there’s a lot of people in this world, and they’re all a little bit different.” “It’s about making cool stuff for a lot of people.”

Show Links:

Show notes compiled by Ben Griswold. Thanks!

Download / Listen:

Herding Code 86: Saqib Shaikh on Accessibility and Developing with Limited Sight

Audio clip: Adobe Flash Player (version 9 or above) is required to play this audio clip. Download the latest version here. You also need to have JavaScript enabled in your browser.

While at Web Camps London, Jon grabs a quick 15 minute interview with Clint Nelsen to talk about Startup Weekend .

  • Clint gives the elevator pitch and a brief history of Startup Weekend.
  • Jon talks about how they are incorporating Startup Weekend into Web Camps. The guys talk about project implementation.
  • Clint talks about Startup Weekend growth, reach and staff and facilitator involvement.  Clint talks about the management aspects of Startup Weekend.
  • Jon asks the types of application which Startup Weekenders are pitching. The guys talk about monetizing iPhone and iPad applications and Jon asks about Windows 7 Phone apps.
  • Clint talks about the benefit of having developers at Startup Weekend knowing a common framework/language.
  • Jon asks about Startup Weekend success stories like Twitpay and Foodspotting.
  • Clint talks about community building, relationships, launch support and current startup funding ratio around 5%.
  • Client and Jon talk about startup thinking in the Microsoft community and building a business around MS technologies.

Show Links:

Show notes compiled by Ben Griswold. Thanks!

Download / Listen:

Herding Code 85: Clint Nelson on Startup Weekend

Audio clip: Adobe Flash Player (version 9 or above) is required to play this audio clip. Download the latest version here. You also need to have JavaScript enabled in your browser.

This week on Herding Code, the guys talk to Jeff Cohen, Mike Moore, and Scott Bellware about why and how they’ve moved away from Microsoft development and into the Ruby community.

  • K Scott asks the guests about why they switched. Jeff talks about how his switch from desktop development on Windows to Rails development started around 2005 and was primarily driven by the Ruby language itself. Mike agrees that it’s all about the Ruby language. Scott B talks about how he straddles both worlds but only sees .NET as a smart choice for building Windows applications now. Scott B goes on to talk about how it’s a philosophical thing for him as well, and how he prefers to work on a stack that’s more purely open source.
  • Scott K talks about the dichotomy in moving from Windows to get away from a proprietary platform and then you find yourself working on a Mac. Go Debian! Scott B talks about how Vista was a tipping point for him to move to Mac. He felt like Microsoft was too focused on shipping products – even if they weren’t good products.
  • Mike and Scott B talk about moving from ALT.NET to ex-.NET, and how they feel like it’s fear and investments in the .NET platform that prevent more people from moving. The guys talk about the “technology treadmill.”
  • Scott K talks about the problems in “dropping paygrades” in moving from being a senior .NET developer to being a junior developer on another platform.
  • Mike Moore asks why developers are investing in a technology that another company owns. Scott B says it’s not about Microsoft owning .NET, it’s about not being able to make decisions about where the platform is going. He says he sees Microsoft as a manufacturer of 21st century office equipment for large companies with the most influence. It works, but it can be heartbreaking when you see Microsoft moving into markets in a way that’s not as elegant as existing technologies (e.g. Entity Framework) because you know that the surrounding industry will move there, and eventually your work will move there as well. The result is a technology treadmill.
  • K Scott points out that as the average developer, you’re not really in charge of where Linux, Rails, or other open source platforms are heading either. Mike and Scott B clarify; it’s not about ownership so much as trusting where the Rails community is going.
  • Kevin asks Jeff about some recent criticisms he’s made towards Rails 3 recently. Jeff talks about all the things he likes about Rails, but says that he is disappointed that Rails is making changes designed to broaden acceptance and appeal to the enterprise. Despite that, he says that he hasn’t lost faith in where Rails is headed. He brings up the relative ease of doing TDD on Rails as opposed to .NET as an example of how Rails works more like he wants to work as a developer.
  • Scott K talks about how Microsoft has a conflict of interest as a tools vendor, and how a willingness to work with other IDE’s makes moving to other platforms pretty easy.
  • The conversation move towards talking about how Intellisense affects system and platform design. Other platforms like Rails are built so you don’t need Intellisense to be productive. Rails was never built to sell anything, and that shows in the platform. Mike talks about how he had to leave the .NET platform to find a place where people really cared about getting from 12 lines of code to 4 lines of code.
  • Scott B talks about how Rails committers are all building Rails applications, and points out that WPF didn’t get the attention it needed until Microsoft used it in Visual Studio. He then talks about how Rails will feel free to make modifications (monkey patches) to Rails, which often graduate to plugins and then move into the core. The key is that this is a continuous process rather than focused on a big product release cycle. Scott B talks more about the Ruby/Rails meritocracy.
  • The conversation shifts to the entrepreneurial nature of the Ruby on Rails community. Mike talks about how development cost is a major factor and that people who will take a risk in moving to a new platform are also more likely to take a risk in business.
  • Mike and Scott B talk about how polyglot programming is much more prevalent outside of the Microsoft development community.
  • Scott B talks about how ASP.NET was positioned as a competitor to Ruby On Rails, and how the two differ.
  • K Scott asks how much the move away from .NET is based on culture and developers are looking for a new community with different values. Mike talks about how he was on the verge of leaving programming altogether when he found the Ruby community, and how it reinvigorated him. Scott B says that there are things about developing in the .NET space which drive burnout and, in turn, reduces passion in the community. Jeff talks about how stumbling on Ruby showed him that it was just a lot more fun than what he was doing in his current job.
  • Scott B talks about how the plugin experience in Rails differs from the .NET development world – where you’re often waiting for services that just aren’t quite there yet.
  • Mike and Scott B talk about how they like reading Ruby code. Scott B talks about how the Ruby culture places a value on making code readable to the point that it’s competitive.
  • Scott K talks about how programming has become a business now, but he’s always liked to learn things just because it was fun. Scott B says that the skill level in the Rails world seems to be higher, but the people are less intimidating.
  • Mike points out that many of the leaders of the Ruby community were previously leaders in the Agile community. Scott B talks about how he’s seen Uncle Bob Martin moving to Rails over the past few years.
  • Scott B then talks about the problems in toolmakers who make tools but don’t use them.
  • The show ends, but not really. lots of crazy speculation about starting over with a new runtime on top of .NET.

Show Links:

Show notes compiled by Ben Griswold. Thanks!

Download / Listen:

Herding Code 84: Ex-Microsoft Developer Panel with Mike Moore, Jeff Cohen, and Scott Bellware

Audio clip: Adobe Flash Player (version 9 or above) is required to play this audio clip. Download the latest version here. You also need to have JavaScript enabled in your browser.

This week on Herding Code, the guys talk with Ayende Rahien (a.k.a. Oren Eini) about RavenDB, a new Open Source (with a commercial option) document database for the .NET/Windows platform.

  • The shows starts with a general definition of document databases.  Ayende then contrasts RavenDB with two other popular document databases, Mongo and CouchDB, and comments that RavenDB is much more similar to CouchDB than Mongo.
  • Ayende talks about how RavenDB indexes work – they’re written when you store data, but not immediately after. He continues with an explanation of transactions – data is transactional, but indexes aren’t.
  • Scott K brings up Node.js and asked if Ayende had looked at the event driven approach over spinning up threads. Ayende talks about how RavenDB previously worked like that, but it made debugging very painful. Instead, the architecture is now focused on the end goal – RavenDB will never make you wait for a write.
  • The guys take a question from Twitter about whether there are plans to support Mono. Ayende says yes, but outlines some of the changes that will be required to make that happen.
  • Scott K asks if traditional RDBMS performance tweaks based on moving data and indexes to other spindles are possible and useful on RavenDB.
  • Jon asks about how this relates to Reactive Extensions, and Ayende discusses how Event Sourcing works in RavenDB.
  • Jon and Scott K ask some questions about storage formats – JSON, binary serialization, etc.
  • The group digs into how Map / Reduce works.  Ayende explains Map / Reduce in generally terms as well as how it pertains to RavenDB.
  • K Scott asks questions about indexing – how it’s done, how indexes are defined and impacts of keeping a lot of indexes. Ayende talks about how indexes are essentially materialized views, and how the RavenDB query engine can use both LINQ and Lucene syntax.
  • K Scott asks about transaction support, embedded support, and concurrency.
  • The guys talk about the “sweet spot” for RavenDB and document databases. Ayende talks about advantages of working with a document database, and the benefits of working without a defined schema.
  • Jon asks if ORM’s just go away in a document database context and the conversation moves on to talking about different architectures and development strategies that come into play when working with schema-less documents.
  • K Scott mentions that this seems like it would work really well with Aggregate Roots in Domain-Driven Design.
  • Ayende and Jon discuss how aggregate queries compare in the context of some of the inefficient queries in MVC Music Store.
  • Kevin drills a little deeper into the versioning challenges.
  • Jon asks about the use of .NET 4 features with RavenDB including the Task Library and the Expando object. Ayende talks about how they made heavy use of the Dynamic keyword and MEF in RavenDB. Basically, everything except for storage and indexing is handled via MEF.
  • Ayende talks about the extensibility points such as read and index previews.
  • Jon begs for punishment by asking for Ayende’s comments on the MVC Music Store. Ayende talks about how he prefers tutorials be very explicit about what they’re not going to cover in detail. He recommends completely removing details which aren’t the focus of the tutorial. Then he goes on to talk about how things like shopping carts just seem to work more smoothly with document storage rather than relational databases.
  • Jon asks about the licensing models. Ayende talks about how people were unhappy with the initial pricing model due to the differing deployment expectations, and how he worked with customers to establish a pricing model that works for everyone.
  • Ayende teaches the gang the term “Chinese Interesting.”

Show Links:

Show notes compiled by Ben Griswold. Thanks!

Download / Listen:

Herding Code 83: Ayende Rahien on RavenDB

Audio clip: Adobe Flash Player (version 9 or above) is required to play this audio clip. Download the latest version here. You also need to have JavaScript enabled in your browser.

This week on Herding Code, Cory Foy and Will Green join the guys to discuss general differences between .NET and Ruby development approaches. Is the grass always greener on the other side? Listen in on this week’s talk about how languages, frameworks, tools and cultures shape the way we implement .NET and Ruby solutions and judge for yourself! 

  • Kevin kicks off the conversation noting differences between design patterns and best practices in the .NET and Ruby worlds. Kevin opens up a discussion by calling out the .NET developer obsession with persistence ignorance versus the use of the ActiveRecord pattern found in Ruby on Rails. 
  • Cory talks about basic CRUD applications vs complex domains and how applications tends to model themselves after organizational structure.  Often times you will find .NET code tends to be more complex whereas simpler domains are often represented in Ruby code.
  • Kevin asks about domain-driven design. Cory talks about the expressiveness of Ruby code and how the introduction of the dynamic keyword makes expressiveness a little easier in .NET.  Will talks about Ruby mixins facilitating a different development approach.  Will also comments on the ceremony of creating .NET vs Ruby classes and how easily you can express the business concerns in Ruby.
  • Scott K talks about his general impressions of Rails – focus on the presentation layer first rather than a DDD approach which would focus on the model first.
  • K Scott talks about manifest typing and states that there is an importance placed on types rather than behaviors in .NET coding.  Will calls out the fact that in .NET coding we often are most interested in what an object is whereas in Ruby we primarily care about what an object can do.  This ties back to static typing vs duck typing.
  • Cory speaks to outside-in development in Ruby, exposure to TDD and learning Rails with Cucumber from the beginning. 
  • Jon acknowledges the language and framework differences and asks how cultural differences between the two development camps might drive development practices.  K Scott talks about .NET developer dependence on the compiler rather than working with customers.
  • Kevin talks about the “need” for viewmodels in .NET MVC whereas models are being passes around throughout a Rails application. Cory talks about the power of meta-programming in Ruby and the shift between classes being parsed in .NET vs classes being executed in Ruby.  He also speaks to how fundamental constructs will shape a development strategy.
  • Cory talks more about meta-programming and convention over configuration.
  • Kevin talks about the “No Magic String” rule, static analysis, and Resharper-driven development.  Will states you don’t really need refactoring tools or even an IDE when coding Ruby. Cory talks about the emphasis on writing tests for Ruby code and how this acts as a replacement for the static code analysis testing you might get from the compiler. Scott K speculates that there’s so much more code in C# so there’s a larger need for refactoring tools. 
  • Cory ask why we are still not testing in the .NET world? Why aren’t we doing migrations?  Why are we so focused merely on what is available in the Visual Studio IDE?  Scott K feels .NET developers are still unsure of what they should test.  Scott K also thinks it is hard to mock stuff and .NET developers aren’t used to writing decoupled code. Will speaks to the fact that Ruby all classes are open all the time and nothing is sealed.
  • For better or worse, Jon notes that it’s easy to think of the compiler as the first .NET test and, though it could be considered a crutch, the IDE provides one with a lot valuable coding help with intellisence. Cory talks about craftsmanship and how the primary audience for IDE support and refactoring tools is not the TDD developer.
  • Kevin speaks to the fact there’s no need for an IoC container in Ruby and Cory shares the dangers of becoming married to any framework in .NET development.
  • Jon asks if Ruby development can become unwieldy because it’s so easy to get started. 
  • Scott K asks about new language features (for examples, lambdas, dynamic keyword, optional parameters) and how this adds to the complexity of .NET development. Will talks about complexity vs power and Cory adds that new features allows developers to approach problems differently.
  • Kevin asks about techniques which can be used with the dynamic keyword.  Scott K talks about the addition of Eval() in C# 5.  Jon jokes about the “Compiler as a Disservice.”  Cory talks about fundamental challenges with Dynamic and Eval() in a statically typed language.
  • The guys talk about dependency injection.
  • Cory talks more about craftsmanship and code quality. Will talks about values and taking a stance when promoting a frameworks and points some blame at Microsoft for giving .NET development dozens of ways to complete a single task.
  • Kevin asks about the focus around Behavior-Driven, integration testing in Ruby rather opposed to the fine-grained unit testing approach often found in .NET development.  Will speaks to the outside-in testing approach but also the importance of unit testing in Ruby.
  • Scott K asks if IronRuby makes .NET development easier.
  • The show wraps with Will and Cory pimping their up-coming presentations in Florida and Norway.

Show Links:

Show notes compiled by Ben Griswold. Thanks!

Download / Listen:

Herding Code 82: Cory Foy and Will Green Compare .NET and Ruby Development

Audio clip: Adobe Flash Player (version 9 or above) is required to play this audio clip. Download the latest version here. You also need to have JavaScript enabled in your browser.

This week on Herding Code, the guys discuss compare notes on how to teach software development topics. Is hands-on instruction key? How much should you simplify to focus on mechanics? How do you teach, and how do you like to learn?

  • Jon talks about his impressions on the effectiveness of hands-on learning at Web Camp Toronto.
  • K. Scott questions if people really learn at Code Camps, and Scott K. talks about hack-a-thons at Code Camps.
  • We talk about open source contributions as development. Jon demonstrates that he’s bad at doing math while he talks.
  • Jon asks Scott K. about what works for him with his training classes with Pluralsight.
  • We all talk about the MVC Music Store, and the gaps between marketing, introductory training, and advanced training.
  • Jon and K. Scott talk about the difficulty in finding the correct focus and simplicity level in introductory training.
  • Jon talks about the mistake he’s made several times in not clarifying the level of content he’s presenting.
  • Kevin talks about how he expects to see unit tests in any samples, but Scott K. says that won’t save you from public shame.
  • Scott K. asks if we should be focusing on concepts and “why?” questions rather than products or frameworks.
  • Jon and Scott K. talk about the fun of looking at the ASP.NET MVC source code.
  • Kevin comments on the difference in complexity he sees in .NET code and Ruby source code. Scott K. talks about how Fubu MVC code is pretty easy to read, too.
  • Jon asks about the difficulty of doing “real world” samples, and K. Scott asks whose real world we’re talking about.
  • K. Scott drops a surprise mini-lightning round on us with a question about the effectiveness of video as a learning tool.

Show Links:

Download / Listen:

Herding Code 81: Simplicity, balance, and focus in teaching software development

Audio clip: Adobe Flash Player (version 9 or above) is required to play this audio clip. Download the latest version here. You also need to have JavaScript enabled in your browser.

This week on Herding Code, the guys speak with Jeffrey van Gogh and Matt Podwysocki about the Reactive Extensions for Javascript.

  • Matt talks about how he’s been involved with RxJS.
  • Jeffrey talks about how RxJS and Reactive Extensions came out of the the Volta project.
  • Matt talks about how RxJS simplifies the callback model in Javascript.
  • Jeffery adds on how this also has benefits to asynchronous operations.
  • Jon asks about how this works with queries over events which will happen in the future.
  • Mat talks about how this works with jQuery’s bind and live events.
  • Jon asks the standard question about querying over mouse move events. Matt and Jeffrey use the example to explain about how composable operations over events can be really powerful.
  • Jon asks how Reactive Extensions relates to functional reactive programming, and to functional programming in general.
  • Kevin asks about how RxJS interoperates with jQuery.
  • We take questions from Twitter about jQuery integration and use of RxJS to manage script loading and script scoping.
  • Kevin asks for some concrete usage examples.
  • Kevin asks about the library size and the overall release status.
  • Jon asks about Jeffrey’s blog posts on using RxJS with Node.js and Script#.
  • We talk about Matt’s extensive blog post series on RxJS.
  • We talk about recent RxJS presentations: Erik Meijer’s talk at MIX10, Jeffrey’s talk at JSConf, and Matt’s at the Imagine Cup.
  • Jon asks about what exactly is involved in adding RxJS support to different Javascript libraries.
  • Scott K asks about the tradeoffs of bringing the CLR to the browser vs. bringing things like RxJS into the browser via Javascript.
  • We talk about how Javascript development has gotten easier with development environment improvements, testing systems, etc.
  • Matt talks about how it’s often easier to do things in Javascript than in a statically typed language like C#.
  • Scott K asks about how scope is handled in RxJS.
  • Jon asks about how the code is licensed.
  • Kevin asks about the naming conventions used in RxJS, supported browsers, release plans.
  • Jon asks about Reactive Extensions for .NET, and we talk about how it’s especially useful in Silverlight.
  • Jeffery mentions that Reactive Extensions will be included in Windows Phone 7.
  • We pretend to end the show, but the discussion keeps going and K Scott joins the party.

Show Links:

Show notes compiled by Ben Griswold. Thanks!

Download / Listen:

Herding Code 80: RxJS with Jeffrey van Gogh and Matt Podwysocki

Audio clip: Adobe Flash Player (version 9 or above) is required to play this audio clip. Download the latest version here. You also need to have JavaScript enabled in your browser.

This week on Herding Code, the guys speak with Chris Williams, Rey Bango and Matt Podwysocki about this year’s JSConf.

  • Chris begins the show with a conference overview which will leave you chomping at the bit for JSConf 2011 registration to open. Hackers’ Lounge. Multiple tracks. One killer speaker list. Hyper-caffeinated, hyper-intoxicated privates! Salmagundi. And lots of JavaScript!
  • The guests discuss their favorite parts of the conference. Beyond the quality of the talks, Rey and Chris both comment about the invaluable conversations which were had out-of-session in the Hacker’s Lounge and at the ScurvyConf. Quote of the Show: “I am a firm believer of drinking beer, and shooting the poop, and when you do that, magic happens.” – Chris Williams
  • Chris talks about the excitement around Tobias Schneirder’s presentation on Gordon, an open source Flash runtime written in pure JavaScript.
  • The guys talk about Alex Russell and Google Chrome Frame and how IE6 must Die.
  • Chris praises Billy Hoffman’s JavaScript’s Evil Side presentation.
  • K Scott and Chris talk about JavaScript outside of the browser and functional programming,
  • Chris and Scott K talk about a seemingly new found interest in Server-side JS
  • Jon asks about JS library duplication in competing platforms. Rey talks about what Resig has done with Sizzle and how each library has their own niche.
  • Chris talks about the need to learn JavaScript and how we should be JavaScript developers, not just developers who use JavaScript libraries.
  • Matt teases us by mentioning that he’ll be talking about Reactive Extensions on next week’s Herding Code episode.
  • Jon asks which percentage of cool JavaScript stuff is just waiting on browser adoption.  Chris doesn’t think too much and prompts Matt talks about progressive enhancements.
  • Chris talks about the importance of security and how we shouldn’t only be taught how to write good code but also how to break bad code.
  • Kevin asks what is happening with JavaScript, the language itself.
  • The show wraps with talk of diversity in computing, JSConf EU, JQuery Conference, JQuery UI 1.8 release, JavaScript conferences and craft beers in the D.C. area.

Show Links:

Show notes compiled by Ben Griswold. Thanks!

Download / Listen:

Herding Code 79: JSConf Recap with Chris Williams, Rey Bango and Matt Podwysocki

Audio clip: Adobe Flash Player (version 9 or above) is required to play this audio clip. Download the latest version here. You also need to have JavaScript enabled in your browser.

[view list of all posts]