Presentations this week

This is going to be a busy week for me with presentations I’m doing at different places. Here’s the schedule:

Tuesday, Sept 22: Speaking at the Frederick .NET User Group

  • Refactoring, Patterns, new language features, code quality, and more! with Claudio Lassala

Command design pattern, Lambda Expressions, Extension Methods, fluent interfaces, refactoring, test-driven development, writing elegant code, and more. This session will cover a little bit of many things learned from projects I’ve been working on. We expect every attendee to learn a few tricks that can be applied immediately, and also to feel encouraged to go out and research more on whatever area appeals the most. Besides learning those things, we really hope attendees will start thinking and approaching their code in a different way.

Wednesday, Sept 23: SOLID Series for the Virtual ALT.NET

  • The Open/Closed Principle, and the Liskov Substitution Principle

Saturday, Sept 26: Houston TechFest

  • Beyond the Core Concepts of OOP (SOLID)
    • You’ve been learning about the core concepts of Object-Oriented Programming (OOP) for quite some time now: Abstraction, Encapsulation, Inheritance, and Polymorphism. When you thought you knew it all, all of a sudden the cool kids are talking about all these principles such as "Single Responsibility Principle", "Open/Closed Principle", "Dependency Inversion Principle", as well as Inversion of Control containers, etc. This session presents those concepts so the attendees can understand what they are and start using right away.
  • Building a Composite WPF Application
    • In this session we create a composite application in WPF, built following the Composite Application Guidance for WPF (codename Prism). The sample application is simple, but most of it is written during the session, covering both the main components of Prism, as well as the Model-View-ViewModel pattern and dependency injection.
  • Isolating Dependencies in Unit Tests Using Mocks and Stubs
    • Soon after getting used to writing "unit" tests, developers tend to realize that those tests weren’t really testing "units"; they were testing way more than that. In order to write real unit tests, it’s necessary to use test doubles such as mocks and stubs. This session covers how to create and use those, and how to use Rhino Mocks to simplify things further. As we learn about those things, we’ll also learn about the importance of thinking through how we write our code, putting thought into the dependencies that a class may have, and how things should be split up.

I hope to see you at any of these events!  🙂

Advertisements
  1. #1 by Jonathan on September 21, 2009 - 11:45 am

    I just have 2 presentations at Techfest and am a nervous wreck.. you are crazy! 🙂

  2. #2 by Claudio on September 23, 2009 - 9:12 am

    We\’ll work on that. 🙂

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: