Derik Whittaker : Conference

1st Chicago Code Camp in the Rear View Mirror

Derik Whittaker — Mon, 01 Jun 2009 19:20:00 GMT

Wow, what a great Code Camp. This past weekend we held the first Chicago Code Camp in northern Chicago. I think we had over 200 people show up, which is not too bad given it was our first event. We had 32 session ranging from .Net to TDD to Ruby and beyond.

I personally sat though 2 different sessions.

1) Aaron Erickson – Code that rights codes: This was a great session to which showed exactly how expression trees did and how they could be utilized in your application

2) Micah Martin -- Ruby Kata: This session was great, but a bit different. Micah’s goal was not to show too much code, but rather talk about how you need to practice or perform Kata’s in order to grow your skill. After about 30-45 minutes of conversation Micah sat down and created an application in front of the group and did so with the understanding that we were going to grade him on the skill/technique of the code.

I would like to personally thank Tim, Scott and Sergio for their hard work to help make this great event come to life. I would also like to thank everyone that showed up to help us run the event as well as the people who took the time out of their Saturday to attend the event. And last, but not least we need to thank the sponsors which helped make this possible.

See everyone at the next one.

Till next time,

Chicago Code Camp Session List (99% final)

Derik Whittaker — Thu, 30 Apr 2009 19:32:00 GMT

We have finalized the session list for the Chicago Code Camp (may changes if speakers have to bow out).

Below is the sessions that will make an appearance at the camp

Speaker	Session Title
Aaron Erickson	Code that Writes Code
Aaron Erickson	Introduction to F#
Chris McAvoy	Python
Cory Miller	Introduction to Silverlight 3, what’s new, a developer perspective"
Curtis Mitchel	Rails-like development using ASP.NET
Dan Nawara	Haml/Sass/Tenplate
Dean Wampler	Better Ruby through Functional Programming
Dean Wampler	The Seductions of Scala
Derik Whittaker	Guarding your code with Code Contracts
Derik Whittaker	Take your test to the next level with an Isolation Framework (RhinoMocks)
Dru Sellers	MassTransit
Eric Smith	TDD for the iPhone
Jim Suchy	TDD and JavaScript
Jim Suchy	iPhone on Rails
Keith Dahlby	Introduction to PowerShell
Kevin Gisi	Adding REST, AJAX and Microfromats to any website
Larry Clarkin	Spark View Engine
Len Smith	Get rolling with NHibernate
Len Smith	jQuery Magic
Marc Temkin	Data Visualization with WPF
Micah Martin	Develop your Graphical User Interfaces (GUIs) faster than ever, with a thorough suite of unit tests to boot."
Micah Martin	Ruby Kata and Sparring
Michael Eaton	An Introduction to Castle ActiveRecord, or How to stop writing CRUD"
Michael Eaton	Developing Solid WPF Applications
Michael Hall	Introduction to AOP with PostSharp
Narayanan Kulasekar	Tools to build an effective Extract, Transform and Load (ETL) process"
Perry Hertler	TDD in the Real World
Rob Lambert	Building and Deploying a Ruby on Rails Application on Amazon EC2
Scott Seely	Introduction to Google App Engine (GAE)
Sean Blanton	Trends in Continuous Integration and Software Delivery
Tim Barcz	Beginner's Guide to Unit Tests
Tim Barcz	Regular Expressions for the .NET Developer

If you would like to attend the camp please signup here:

Till next time,

Upcoming Speaking Engagements

Derik Whittaker — Sun, 09 Nov 2008 22:53:07 GMT

Just wanted to send a message out there to anyone that is going to be in the Raleigh/Durham area this week. I will be giving 2 talks this week. One at TriNug and another at the Raleigh Code Camp. If you are in the area and want to stop by to heckle me, please do.

Info on the 2 sessions

TriNug - Taking your Tests to the next level with Mocks

This session will walk through the progression of testing with mocks. We will learn how using mocks, and mocking out dependencies will increase the reliability of your tests. We will also learn why it is important to remove any dependencies that are out of your immediate scope. We will do a quick overview of TDD using NUnit, but the crux of the session will be focused on mocking with RhinoMocks along with the StructureMap AutoMocking Container

Code Camp - Bending the Asp.Net MVC to do Your Bidding, the Virtues of Extensibility

Most frameworks only meet about 80% of our actual needs. This could be due to our unique business needs, because the framework has made some wrong assumptions, or because the framework has a different scope. Therefore, it is the wise framework that recognizes this and builds in extensibility points.
In this session we will learn how to bend the ASP.Net MVC framework to your will. The ASP.Net MVC framework was built with extensibility in mind. Almost every part of it is extensible, from the view engine to the controller factory to the routing engine. We will learn how to make use of the various extension points in the framework and make it do our bidding.

Hope to see everyone out there, both sessions should be great. Even if you have no interest in hearing my MVC talk I encourage you to still attend the Code Camp as there will be great content.

Till next time,

KaizenConf Wrap Up -- What an Exhausting Learning Experience

Derik Whittaker — Mon, 03 Nov 2008 00:53:04 GMT

Well, that does it for this years KaizenConf. I can honestly say that I had a great time, I met some great people (nice to put faces to twitter handles) and shared some great stories. What is great is that when I setout to make it to this openspace conference I had a ton of questions. I walk away from the event with a lot of answers, a lot of gained knowledge and not surprisingly more questions.

It may seem odd that I have more questions in the end then in the beginning, but that is a sign of learning. I now know more and this additional knowledge has lead to more questions.

I have posted the wrap-up comments for the 2 sessions where I was the convener (2 of my topics/sessions that I suggested were selected) and you can get them here

The output of all of the sessions are being documented in a Wiki, and you can find it here.

Final thoughts on the conference

Wow, am I exhausted.....! I have been to my share of technology conferences, but I can say I am more exhausted after this one than any other. The reason for this was the amount of engagement and thinking that needed to take place. At most tech conferences you sit back and listen to someone present (or hopefully teach) on a given topic. Not till the end does the audience have a chance to interact.

With this there were no planned sessions (in terms of having PPT slides or code ready) and no one person 'lead' any of the sessions. Each of the sessions were run by the group and went into the direction the group directed (aka as an open space should). During each of these sessions you forced to get involved or you were passed over. because of this involvement you learn a ton, but become exhausted.

I will take a little exhaustion for the amount of knowledge gained over the past few days. :)

I have to say one of the highlights of the weekend was dinner on Friday. A few of us just decided to head back to the hotel bar for dinner and brew. About 30 minutes after we sat down Mary and Tom Poppendieck sat down with us. They are 2 of the nicest, sincere and down to earth people you can meet. Even with all their knowledge and experience we (the entire table) were able to have an open and engaging conversation about lean and continuous learning.

Final thoughts in regards to the name/context change from Alt.Net to KaizenConf

Back when the conference was announce Scott Bellware took a ton of heat for changing the name of the conference from the Alt.Net conference to the Kaizen Conference. Many people in the community really did not see any reason for changing the name and thought that it was done for various self serving reasons.

Having been to the conference, I know understand what his goal/intent was with the conference. This weekends openspaces was NOT about technology. I say that with 100% sincerity. Sure there were topics out there on Rhino, IoC and MassTransit, but that was simply one track out of 5. The majority of the sessions were around how we can help bring change to our organizations and more towards the idea of continuous learning.

Till next time,

KaizenConf - Open Communication, Resistance to Change, Going with the Staus quo w/ reference to various team roles

Derik Whittaker — Sat, 01 Nov 2008 20:20:55 GMT

Another session that I sat in on today was "Open communication, Resistance to change, Going with the status quo with reference to the various roles on the team "

If I could wrap up the entire session in a phrase it would be the following:

When your team feels empowerment and has passion they will be successful

Below are my notes, sorry they are not in a long descriptive form, but they are notes :)

Quotes:

The product champion doesn't figure out what the market wants, but brings the team to the customer
Without a good leader, or a champion of the team your team is doomed to fail
Quailty is building a substainable releationship
the value of value is realitive worth
When you do not have the fear of being fired you can become more open

Questions:

What are the barries to opening communication
- Management/customer sees the release cycle/process as a tax
How are we defining Continous Improvement?
- taking notices of our process our, release cycle
- balancing various items like maintainability, without over engineering our product
What is value????
- this means differnt things to different people
- means that someone will always be unhappy
- operations has more work with more installs -- they are unhappy
- developers have have more pressure if they have more work load
- one persons pain is another persons pleasure
How do we make change when we are capiable of influincing change, but not the permissionr
- start local
- start small
- hope your ideals spread
How do we move from me to we
- get buy in from all on the team goal
- get ownership
- have pride/passion
How do we get a team to become engaged or passionate
- ownership
- self correction, self moderation
- foster that the project will be a success
- stay positive
4 areas of improvement
- improvement of skills on the team
- improvement of the purpose of the product
- improvement of the process
- improvement of the releationships

Till next time,

Kaizenconf day 1 wrap up

Derik Whittaker — Sat, 01 Nov 2008 11:52:03 GMT

Yesterday was day 1 of this years KaizenConf and it got started off with a bang. I was not able to make it to most of the conferences pre-conference workshop, but I was able to make it to one.

Fluent APIs with C# - Chad Myers

Chad put together a great workshop about how to leverage the C# language to build DSL's/Fluent Interfaces. He walked the group through the various type of DSL's and how each one can be created and used. He did a nice job of backing up each of the DSL types with pretty simple and easy to follow examples. By the end of the session the group really was getting into the why of DSL's and how they can be beneficial to your team.

Planning the Openspaces

The kickoff to any openspaces conference it the planning session. Kaizen was kicked off with a bang, Scott Bellware and Doc (sorry do not know his last name) did a great job of setting up the rules of the conference and then leading us to a great planning session. What was really cool is that the majority of the sessions proposed where non-technical in nature (meaning there were only a few 'how do I use XYZ technology).

The reason I am happy about the lack of technical sessions proposed is because the majority of the sessions are on lean, Kanban and general improvement topics. And since this is a Continuous Improvement in Software Development Conference, this is exactly what I was looking for.

I am looking forward to today's sessions and am plan on learning how I can help to bring awareness and change to my organization.

Post Planning Beers

Some would say that this type of conference is really about the social interactions outside the actual conference. Typically I would agree with this and tonight was no difference. After the planning session a few of us headed back to the hotel bar to have few drinks and great conversation.

What really set this 'beers and chat' session apart from many others is that the Tom and Mary Poppendieck joined us (if you do NOT know who they are you really need to read their books). It was awesome to be able to pick their brains and gather years worth of insight. If you just sit back and listen to what they have to say you would be amazed with the amount of experience and insight they have and how they are both able to convey there experiences in a clear and concise manor.

Another really great thing is that I am able to meet some people that I have been interacting with (via twitter, IM, etc) for many months. It it always nice to be able to put a face to a name/twitter handle.

Looking forward to what todays sessions bring..... stay tuned it should be good.

Till next time,

Iowa Code Camp in the rear view mirror

Derik Whittaker — Sun, 04 May 2008 16:31:00 GMT

Well, it is official, the Iowa Code Camp has come and gone. Yesterdays event was awesome. They had about 125-150 people show up for the first ever Code Camp in Iowa. The venue could not have been any nicer and setup any better.

There were a total of 5 tracks each with 5 sessions. I had signed up to do 2 of them (listed below) and I think they both went off pretty well (more below).

0 to CI in 1 hour or less

This was my first session of the day and it went pretty well. Had about 12-15 people in the session and they asked great questions. By the end of the hour we had a full blown (yet simple) Continuous Integration server up and running that would Pull from VCS, Compile, Run Tests, Run Coverage and finally Publish to a Network location.

The PPT and scripts for this session can be found at the botton of the post:

Taking your tests to the next level with Mocks

This was my second session and I had a full run of about 25 attendees and boy did they ask a ton of great questions. I actually had to cut this session short as we started to run out of time, which is never a bad thing. What was really cool about this session was how mocking really started to click with a few different people by the end of the session.

The PPT and source for this session can be found at the botton of the post:

0 to CI in 1 hour or less -- Round 2

One thing that was really cool is how we had a 'bonus session' at the end of the day. This session was voted on by the attendees as the one session they had originally missed, but wanted to see. Turns out my '0 to CI' session was the lucky winner so I presented this as an encore presentation. I was really happy people wanted see my CI session, but doing 3 sessions in a day is pretty rough.

After Party

Lets be honest. The after part is where it is at. This is a time for everyone to mingle and talk shop and boy did we do that. Javier, Greg, Greg, Chris and gang (sorry i could not list out everyone) did a great job and treated anyone that wanted to attend to a great dinner.

During the after party I had the chance to chat with a lot of great guys (gender neutral term here) and finally put some faces to 'online personas' as well as meet a ton of new people. What was really cool is I was able to meet up with a few readers of the blog (proves people actually do read this and it is not just my mom racking up the views).

In closing, great job guys. You ran a class act show.

Till next time,

Deeper in .Net Slides/Sample Code

Derik Whittaker — Wed, 09 Apr 2008 18:16:07 GMT

The slides and sample code for the conference can be found here.

I would highly recommend that you take a look at 'The Scaling Habits of Asp.Net Applications' as well as 'The Science of a Great UI' Both of these were great.

Deeper in .Net wrap up

Derik Whittaker — Sun, 06 Apr 2008 15:20:40 GMT

Wow, yesterday was great. Myself and Jordan Martz make the trek up from Chicago land up to Brookfield WI to attend a great .Net developers conference. The conference had a great turnout of about 400 people that listened to 5 great presentation

LINQ Internals with Visual Basic 9
The Science of a great UI (Mark is a awesome presenter)
The Scaling habits of ASP.Net applications (Richard Campbell did a great job)
Building next generate apps with Silverlight
The Essence of Linq with C# (Charlie did a great job of detailing the internals of linq)

After the conference was over, they had a dinner reception for some of the attendees. The food was great, but the geek talks were even better. I had a chance to chat with Richard Campbell for about an hour. Had dinner with Charlie Calvert (community PM for the C# team), and was able to pepper him with a few questions.

I would like to give a special shout out to the WI-Intea guys, they did a great job putting this together. Scott, Doug and gang you guys did a nice job.

Deeper in .Net (live) -- Essence of Linq

Derik Whittaker — Sat, 05 Apr 2008 22:38:14 GMT

Speaker : Chalie Calvert

The fifth and final session was about diving deeper into Linq. This was a great session. He really dove pretty deep into the guts of linq and how it actually worked. He did not cover a vast amount of linq syntax as that was not the objective, but was still a great session.

7 Major themes to Linq

Integrated
Unitive (single syntax for all data sources)
Hierarchical
Declarative (the what, not the how)
Extensible (linq has endless ability to be extended)
Transformative
Composable

Points of interest from the session

Linq allows the developer to have a single point of contact to many underlying data sources (objects, xml, db tables, file systems, etc)
Showed how easy it was to to use various new language syntax (ie lambda) in conjunction with linq.
Gave a overview/demo on how to use the ORM designer in the IDE to build your relationships.
Showed how to return anonymous types via linq
var query = from c in db.Customers
where c.City == "London"
select { c.City, c.Company };
Linqpad -- kickass linq expression editor/tester
Did a quick overview of how lambda's work since they are so heavily used in linq.
Reviewed how the delayed execution of linq to objects works. This is really, really cool.
Did a really nice review of how things such as the Where extension method works in Linq and how the compiler is smart enough to convert linq statements into separate methods when needed at compile time.
Did a great high level overview of how linq and lambda generate expression trees and how they are used by the compiler and how we can get the information out of the expression tree. (showed the expression tree viewer that comes with the IDE).

Till next time,

Deeper in .Net (live) - Scaling Habits of ASP.Net

Derik Whittaker — Sat, 05 Apr 2008 20:04:40 GMT

Speaker: Richard Campbell (yea, that Richard. But no Carl :( )

The third session today deals with scaling a ASP.net application. Going from the 'make it work' stage to 'make it scale' stage in our developers and how we as developers progress from end to end.

Things we need to measure when talking about scaling
- Capacity - number of active/concurrent users
- Throughput - pageviews, request per second, transactions per second
- Performance - load time (milliseconds)
Reviewed the basics on how to calculate performance
R = (payload/bandwith) + RTT + ( AppTurns(RTT)/concurrent requests) + CS + Cc
R == Response Time
RTT == Round trip time
Cs == Server side compute time
Cc == Client compute time
Pointed out that many times our 'performance issues' are not always in the code. Sometimes we need to take a look at either bandwith or roundtrip information/stats.
Reviewed what 'server failure' typically looks like
Memory consumption above 80%
Processor consumption at 100%
Request queues start to grow out of hand
Page timeouts
Sessions get lost
People cannot access the site
Talked about the fallacy between 100% uptime vs 99% uptime. 99% should be the goal, not 100%
When over the topics of discussion when you have the 'the sky is falling' meeting after a site goes down. The idea here is that developers should be ready to fully discuss the app from all aspects and the opps team needs to be ready to review the network setup/usage in great detail.
Made suggestion that if/when you move from one server to two, you might as well as move to three because the cost of two to three is simply the cost of hardware. The move from one to two is very expensive. May also want to separate the duties of the web servers. Make one an image server ONLY.
Chatted about when using load balancers you need to be aware of what type of balancing you need, and what type will work best for you. Sticky vs Round Robin vs WMI.

Till next time,

Deeper in .Net (live) -- The Science of a Great UI

Derik Whittaker — Sat, 05 Apr 2008 16:11:59 GMT

Author: Mark Miller (Developer Express, iNeta Speaker)

The second session of the day was about great UI's. I thought that this would be how to design great UI's, but no. It really was about how we as developers need to start observing the 'cost' of the UI. How much time/effort it takes for a user to navigate your application as well as how various things such as contrast, color, layout, etc can kill a user's experience.

Mark's speech was both funny (yea, a geek can be funny), but also very well thought out and very informative. He was a great speaker.

Here are some of the topics that he covered

Did an overview of keystrokes and how they are expensive to the user. He has even come up with a point system to calculate the cost of different keystrokes. (letters == 1, Space == .4, Ctrl+S == 2.5)
Did a review of how the distractions of user shortcuts (Ctrl+S, etc) are very costly to a user based and take away from their perceived efficiency or the task at hand. Many, non-intuitive shortcuts name, sequences require memory space.
Went over how long mouse travel kills productivity. We as UI designers need to think about mouse travel when building a UI. Does the user have to go from side to side of the application in order to accomplish a task.
Talks about how various things take away from a users brainpower. Annoying message boxes, vague toolbars, mis-managed UI layout
Edward Tufts book, he swears by this book. A must read for designers.
How contrast and colors can make a huge impact on the UI design. How we should use color to our advantage. Create contrast to draw attention towards or away from various.
Differences of info in Serial and Parallel
Serial - one thing at a time , requires you to remember the past
Parallel - many things at once, does not require you to remember the past.
How UI's can lead to frustration and confusion if they are not clearly laid out. Too much text, and readers will ignore the text.
Do not make the user 'guess' what needs to be done, tell them.
http://kuler.adobe.com -- Nice flash tool for choosing a color pallet to use.
Had a great concept of menus that 'learn' habits based on customer usages. This is a great concept. I guess DevExpress does exactly this. Will need to check this out.

Overall, Mark gave a great presentation. He is very engaging with the audience and gets very involved.

Till next time,

Deeper in .Net Live -- Linq internals with VB 9 (oh yea, VB baby)

Derik Whittaker — Sat, 05 Apr 2008 14:10:59 GMT

Author: Scott Wisniewski

The first presentation of the day is 'Linq internals with VB 9'. The presenter is a Microsofty that made the trek out from Redmond to visit the midwest. The goal of the presentation is to give a high level overview of Linq, and it was pulled of pretty well.

Here are some of the topics that were covered

Showed the 'painful' way of doing data retrieval in .Net 2.0. Then moved on to show how to accomplish the same task via Linq.
Demo'ed how you could override Linq keywords such as Where if you wanted to override the default behavior (hey, I am sure someone will want this).
Demo'ed XLinq, this is pretty cool. Sadly the IDE support is ONLY for VB (damn vb guys). Us C# devs can still use XLinq, but only via the API, we will get no intellisense. Here are 2 postings about XLinq Steve Eichert and DonXML. Actually had a VB developer say to me 'Finally something us VB guys have that you C# do not, we are now a first class citizen' -- Laughed

Ok, this is just my little rant on my VB syntax hates

Using the _ as line separators
Lack of needing () for methods (confusing anyone)
Extension methods are ODD
Non-case sensitive
Lambda syntax is 'ugly'
Function (c) c.SomeProperty = "SomeValue"

Nice overall theme, but would have liked to see more time spent on Linq it self. There was a large percentage of time spent 'building' the test application.

Till next time,