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

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:http://herdingcode.com/wp-content/uploads/HerdingCode-0086-Saqib-Shaikh-on-Accessibility-and-Developing-With-Limited-Sight.mp3]

Herding Code 85: Clint Nelsen on Startup Weekend

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:http://herdingcode.com/wp-content/uploads/HerdingCode-0085-Clint-Nelsen-on-Startup-Weekend.mp3]

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

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:http://herdingcode.com/wp-content/uploads/HerdingCode-0084-Ex-Microsoft-Developer-Panel-with-Mike-Moore-Jeff-Cohen-and-Scott-Bellware.mp3]

Herding Code 83: Ayende Rahien on RavenDB

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:http://herdingcode.com/wp-content/uploads/HerdingCode-0083-Ayende-Rahien-on-RavenDB.mp3]

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

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:http://herdingcode.com/wp-content/uploads/HerdingCode-0082-Cory-Foy-and-Will-Green-Compare-NET-and-Ruby-Development.mp3]