SubText is the engine behind our company blog. With the goal of ensuring a smooth transition between the main website and the blogs, I spent some time tightening up the styles for the aggregate and individual blogs last week.  This required a custom SubText skin and lot of css tweaking.

Though I’ve previously had the SubText source running on my machine, there was no need to update or rebuild the solution in my current case so just went ahead with a local installation using the Microsoft Web Platform Installer (Web PI). 

I just checked the SubText box, provided answers to a few key setup questions (admin user credentials, SubText database, etc) and I was up and running in minutes.  

Once the setup was complete, I was asked if I’d like to launch SubText.  The SubText Installation Wizard picked up where Web PI left off and the setup couldn’t have been easier. 

Web PI provides quick and easy installs for lots of goodies.  Check it out.

I just wrote about how I like to present on unfamiliar topics. With this said, Domain-Driven Design (DDD) is no exception. This is yet another area I knew enough about to be dangerous but I certainly was no expert.  As it turns out, researching this topic wasn’t easy. I could be wrong, but it is as if DDD is a secret to which few are privy. If you search the Interwebs, you will likely find little information about DDD until you start rolling over rocks to find that one great write-up, a handful of podcasts and videos and the Readers’ Digest version of the Blue Book which apparently you must read if you really want to get the complete, unabridged skinny on DDD.  Even Wikipedia’s write-up is skimpy which I didn’t know was possible…

Here’s a list of valuable resources.  If you, too, are interested in DDD, this is a good starting place. 

1. Domain-Driven Design: Tackling Complexity in the Heart of Software by Eric Evans
2. Domain-Driven Design Quickly, by Abel Avram & Floyd Marinescu
3. An Introduction to Domain-Driven Design by David Laribee
4. Talking Domain-Driven Design with David Laribee Part 1, Deep Fried Bytes
5. Talking Domain-Driven Design with David Laribee Part 2, Deep Fried Bytes
6. Eric Evans on Domain Driven Design, .NET Rocks
7. Domain-Driven Design Community
8. Eric Evans on Domain Driven Design
9. Jimmy Nilsson on Domain Driven Design
10. Domain-Driven Design Wikipedia
11. What I’ve Learned About DDD Since the Book, Eric Evans
12. Domain Driven Design, Alt.Net Podcast
13. Applying Domain-Driven Design and Patterns: With Examples in C# and .NET, Jimmy Nilsson
14. Domain-Driven Design Discussion Group
15. DDD: Putting the Model to Work by Eric Evans
16. The Official DDD Site

In this presentation, I provided a brief introduction into TDD and talked about the confusion and misconceptions around the discipline. I, of course, shared a bit about Dan North, the father of BDD and touched upon some crazy hypothesis dreamed up by Sapir and Whorf. I then gave a Behavior Driven Development overview (my impressions of the implementation and lifecycle) and then touched upon available tools, how to get started and I threw in a number of reference and reading materials which you will find below.

As an added bonus, I demonstrated how easy it is to include/exclude hyphens and alter the spelling of “behavior” at will.

1. Introducing BDD, Dan North
2. Oredev 2007 - Behaviour-Driven Development, Dan North
3. Behavior-Driven Development, Scott Bellware
4. Behavior Driven Development, Wikipedia
5. BDD Wiki
6. A New Look at Test-Driven Development, Dave Astels
7. Behavior Driven Development – An Evolution in Testing, Bob Cotton
8. The Truth about BDD, Uncle Bob Martin
9. Language and Thought, Wikipedia
10. Sapir-Whorf Hypothesis, Wikipedia
11. What’s in a Story?, Dan North

I mentioned in a previous post that we’ve started a languages club at the office.  In an effort to decide which language we will first concentrate on, I volunteered to give the rundown on F#.  Rather than providing a summary here, I’ve provided my slide deck for your viewing enjoyment.  There’s nothing special here outside of a some pretty cool characters from The 56 Geeks Project by Scott Johnson and collection of information from my prior functional programming presentations.  

The folks at the Open Web Application Security Project publish a list of the top 10 vulnerabilities. In a recent CodeBrew I provided a quick overview of them all and spent a good amount of time focusing on the most prevalent vulnerability, Cross Site Scripting (XSS). 

I gave an overview of XSS, stepped through a quick demo (sorry vulnerable site), reviewed the three XSS variations and talked a bit about how to protect one’s site. 

References and reading materials were also included in the presentation and, look at that, they are provided here too.

1. Open Web Application Security Project
2. The OWASP Top Ten Vulnerabilities (pdf)
3. OWASP List of Vulnerabilities
4. The 56 Geeks Project by Scott Johnson
5. ha.ckers.org
6. OWASP XSS Prevention Cheat Sheet
7. Wikipedia
8. Is XSS Solvable?, Don Ankney
9. The Anatomy of Cross Site Scripting, Gavin Zuchlinski

We started a work language club at work this week.  Thus far, we have a collective interest in a number of languages: Python, Ruby, F#, Erlang, Objective-C, Scala, Clojure, Haskell and Go. There are more but these 9 received the most votes.

During the first few meetings we are going to determine which language we should tackle first. To help make our selection, each member will provide a quick overview of their favored language by answering the following set of questions:

1. Why are you interested in learning “your” language(s). (There’s lots of work, I’m an MS shill, It’s hip and  fun, etc)
2. What type of language is it?  (OO, dynamic, functional, procedural, declarative, etc)
3. What types of problems is your language best suited to solve?  (Algorithms over big data, rapid application development, modeling, merely academic, etc)  
4. Can you provide examples of where/how it is being used?  If it isn’t being used, why not?  (Erlang was invented at Ericsson to provide an extremely fault tolerant, concurrent system.) 
5. Quick history – Who created/sponsored the language?  When was it created?  Is it currently active?
6. Does the language have hardware support (an attempt was made at one point to create processor instruction sets specific to Prolog), or can it run as an interpreted language inside another language (like Ruby in the JVM)? 
7. Are there facilities for programs written in this language to communicate with other languages?  How does this affect its utility?
8. Does the language have a IDE tool support?  (Think Eclipse or Visual Studio)
9. How well is the language supported in terms of books, community and documentation?
10. What’s the number one things which differentiates the language from others?  (i.e. Why is it cool?)
11. How is the language applicability to us as consultants?  What would the impact be of using the language in terms of cost, maintainability, personnel costs, etc.?
12. What’s the number one things which differentiates the language from others?  (i.e. Why is it cool?)

This should provide an decent introduction into nearly a dozen languages and give us enough context to decide which single language deserves our undivided attention for the weeks to come.  Stay tuned for the winner…

About a year ago, I sent the group a list of my favorite podcasts.  Apparently it’s time I share an updated list of my top 12 subscriptions.  I listen to everything that is published by the folks towards the top of the list, but as you start moving down the list, I tend to listen only if I’m interested in the topic.  Surprisingly, I often am. 

Most of these podcasts should be considered .NET-centric.  However, those which talk to everything and anything technical (at least sometimes) are highlighted with an asterisks.

1. Hanselminutes *
2. Herding Code *
3. Stack Overflow *
4. Elegant Code *
5. Software Engineering Radio *
6. Spaghetti Code
7. .NET Rocks *
8. The Thirsty Developer *
9. Polymorphic Podcast *
10. Deep Fried Bytes
11. Alt.Net *
12. You Look Nice Today *

If you’re interested in checking them out, each show can be found in the App Store or you can import into iTunes using the attached OPML dump. 

I did an in-house presentation on Lean Software Development (LSD) and Kanban Systems recently.  Beyond what I had previously learned from various podcasts, I knew little about either topic prior to compiling my slide deck.  In the process of building my presentation, I learned a ton.  I found the concepts weren’t very difficult to grok; however, I found little detailed information was available online.

Hence this post which is merely a list of valuable resources.

1. Principles of Lean Thinking, Mary Poppendieck
2. Lean Software Development, Mary Poppendieck
3. Lean Programming, Mary Poppendieck
4. Lean Software Development, Wikipedia
5. Implementing Lean Software Thinking: From Concept to Cash, Poppendieck
6. Lean Software Development Overview, Darrell Norton
7. Lean Thinking: Banish Waste and Create Wealth in Your Corporation
8. The Goal: A Process of Ongoing Improvement
9. The Toyota Way
10. Extreme Toyota: Radical Contradictions That Drive Success at the World’s Best Manufacturer
11. Elegant Code Cast 17 - David Laribee on Lean / Kanban
12. Herding Code Episode 42: Scott Bellware on BDD and Lean Development
13. Seven Principles of Lean Software Development, Przemys?aw Bielicki
14. Kanban Boards for Agile Project Management with Zen Author Nate Kohari
15. Herding Code 55: Nate Kohari brings Your Moment of Zen
16. James Shore on Kanban Systems
17. Agile Zen Product Site
18. A Leaner Form of Agile, David Laribee
19. Kanban as Alternative Agile Implementation, Mark Levison
20. Lean Software Development, Dr. Christoph Steindl
21. Glossary of Lean Manufacturing Terms
22. Why Pull? Why Kanban?, Corey Ladas

Note: This post was originally published on johnnycoder.com in August, 2009.

After completing a ridiculous amount of research over the past couple of month, I presented on functional programming early last week.  Even though I’ve playing with F# quite a bit lately, I didn’t focus on any specific functional or multi-paradigm language.  Instead my presentation included an overview of functional programming in general.

Update 4/28/2009: I’ve posted my slide deck.  Check out Part 1 of the Functional Programming Series.

I compiled a good number of references during my research. If you are interested in learning more about functional programming, I suggest you consult any of the references below. Or you may just wish to wait for me to publish my slide deck. 

1..NET Rocks - Show 377: Ted Neward and Amanda Laucher on F#
http://www.dotnetrocks.com/default.aspx?showNum=377

2..NET Rocks - Show 310: Simon Peyton Jones on Haskell and Functional Programming
http://www.dotnetrocks.com/default.aspx?showNum=310

3..NET Rocks - Show 293: F# Moves Forward
http://www.dotnetrocks.com/default.aspx?showNum=293

4..NET Rocks - Show 266: Jon Harrop Makes Us F#
http://www.dotnetrocks.com/default.aspx?showNum=266

5.Deep Fried Bytes - Episode 24: Chatting about F# with Chris Smith and Dustin Campbell
http://deepfriedbytes.com/podcast/episode-24-chatting-about-f-with-chris-smith-and-dustin-campbell/

6.Deep Fried Bytes - Episode 23: Functional Programming in C# with Oliver Sturm
http://deepfriedbytes.com/podcast/episode-23-functional-programming-in-csharp-with-oliver-sturm/

7.Software Engineering Radio - Episode 108: Simon Peyton Jones on Functional Programming and Haskell
http://www.se-radio.net/podcast/2008-08/episode-108-simon-peyton-jones-functional-programming-and-haskell

8.Software Engineering Radio - Episode 89: Joe Armstrong on Erlang
http://www.se-radio.net/podcast/2008-03/episode-89-joe-armstrong-erlang

9.Software Engineering Radio - Episode 84: Dick Gabriel on Lisp
http://www.se-radio.net/podcast/2008-01/episode-84-dick-gabriel-lisp

10.Software Engineering Radio - Episode 62: Martin Odersky on Scala
http://www.se-radio.net/podcast/2007-07/episode-62-martin-odersky-scala

11.Herding Code - Episode 18: Matt Podwysocki on F# and Functional Programming
http://herdingcode.com/?p=45

12.Pragmatic Podcast - Episode 24: Stuart Halloway on Programming Clojure
http://www.pragprog.com/podcasts/show/24

13.Elegant Code Codecast - Episode 24: Matt Podwysocki on Functional Programming
http://elegantcode.com/2009/02/27/code-cast-24-matt-podwysocki-on-functional-programming/

14.Matthew Podwysocki’s Blog
http://codebetter.com/blogs/matthew.podwysocki/default.aspx

15.Wikipedia
http://en.wikipedia.org/wiki/Functional_programming

16.Real World Functional programming in .NET, Petricek

17.Functional Programming for the Rest of Us, Slava Akhmechet
http://www.defmacro.org/ramblings/fp.html

18.Why Functional Programming Matters, John Hughes
http://www.cs.chalmers.se/~rjmh/Papers/whyfp.html

19.Functional Programming HOW TO
http://www.amk.ca/python/writing/functional#introduction

20.Expert F#, Syme, Granicz and Cisternino

21.Foundations of F#, Pickering

22.An Introduction to Microsoft F#
http://channel9.msdn.com/pdc2008/TL11

23.F# Eye for the C# Guy, Leon Bambrick
http://secretgeek.net/content/fsharp_leonb.pdf

I did a presentation on Aspect-Oriented Programming at our company CodeBrew yesterday.  I was really happy with how well the talk came together and I was delighted by all of the positive feedback.

My slide deck generated a lot of buzz.  As you can see, I borrowed heavily from the popular O'Reilly Head First book series.  It took me way too long to put the presentation together but it was definitely worth it.  And it was fun -- fun for me and the rest of the group.
 

I mentioned my recent interest in AOP in last month's professional retrospective.  It's interesting stuff and since I've done much of the legwork already I'm thinking about putting together a short blog series which explains the basics.  All in favor?

Update 4/28/2009: I’ve posted my slide deck.  Check out Part 1 of the Head First AOP Series.