Posts
114
Comments
130
Trackbacks
10
Sunday, August 5, 2012
St. Louis Days of .NET 2012 Wrap-Up

Thanks to all of the organizers and volunteers and sponsors who made this fifth annual event another huge success.

Thanks to all of the speakers, many of whom paid for their own travel and lodging in exchange for free chicken & waffles. My favorites were:

  • Alex Papadimoulis:
    • Beauty is in the Eye of the Beholder (A Talk on Ugly Code)
      Got myself a “WFT” mug!
    • NuGet for the Enterprise
      Thanks for harshing my NuGet buzz, man! Alex alerted us to some of this shiny new toy’s gotchas that my team hadn’t run into yet.
  • Javier Lozano: Advanced ASP.NET MVC
    We don’t get enough advanced presentations at regional developer conferences, in my opinion. I learned a couple of new tricks from Javier’s presentation.
     
  • Mike Eaton: XAML Styles and Templates: Make your apps shine!
    Even though “Get serious about XAML” has been near the top of my to-do list for about five years now, I just completed my first real WFP app. Thanks to Mike for showing me how I should have handled styling.

  • Cory House: Building Secure Web Applications in .NET
    Damn, internets– Why U so evil!?

  • Steve Bohlen: .NET Productivity Gateway Drugs: Becoming a Pusher instead of just a User of Generics and Lambda Expressions
    I’ve seen Steve several times now, and think he may be the best .NET speaker around.

  • Lee Brandt: MVC4, WebAPI and the REST of the Story
    Thanks to Lee, the organizer of the great Kansas City Developer’s Conference, for making the drive over from Missour-uh to Missour-ee.

  • Jennifer Marsman: Getting Started with Windows 8 Development
    Much FUD was dispersed by this extremely energetic MS evangelist whose blood type is apparently “Red Bull”
  • Ted Neward: Busy Developer's Guide to NodeJS
    Best Crockfordian summary of the non-naughty bits of JavaScript (whoops – I forgot – the smart guys call it ECMAScript) I’ve ever seen

A couple of minor quibbles about the venue:

  • I don’t know why the walls between section of the Discovery room weren’t closed all the way this year. The sound bleed-through from the presentation on the other side was distracting.
  • Ameristar, that’s NOT how you do chicken & waffles

I’ve collected a few links to slides, code, and video recordings of some of these presentations from other events:

  • James Hare’s “Little Wonders” and “Of Lambdas and LINQ” – slides & code
  • Scott Kuhn’s “Cross-Platform Mobile Development” – slides
  • Nicholas Cloud’s “Going Postal with Postal.js” – slides & code / video from his St. Louis JavaScript Meetup presentation
  • Phil Japikse’s “SOLID Development Patterns for Mere Mortals”, “Implementing M-V-VM for WPF” and “WPF for Developers” – slides & code
  • Alex Papadimoulis’ “Beauty is in the Eye of the Beholder (A Talk on Ugly Code)” – video from InfoQ
  • Cory House’s “Clean Code – Writing Code for Humans” / “Building Secure Web Applications” – slides & code
  • Jay Harris’ “Going for Speed: Testing for Performance” – slides
  • Michael Friis’ “Making your Application Cloud-ready” – video from NDC
  • Steve Bohlen:
    “Behavior-Driven Development: Turning User Stories into Executable Specifications” – video from UserGroup.tv
    “Taming Your Dependencies with Inversion of Control Containers” – slides and code
  • Ian Lackey’s “Sharing is Caring: Code Reuse in XAML Applications” – slides
  • Michael Querimit’s “JumpStart: Application Lifecycle Management and Team Foundation Server” – slides
  • Clint Edmonson’s "Introduction to Windows Azure Virtual Machines", "Windows Azure Jumpstart", "Architecting Scalable Applications in the Cloud", "Peering through the Clouds - Cloud Architectures You Need to Master” – slides
  • Jennifer Marsman’s Windows 8 “Contoso Cookbook” slides and samples
  • Beth Massi’s Lightswitch webcast and TechEd video

…and if the St. Louis Days of .NET has you jonesin’ to cram your brain with more .NETty goodness, for more, why not roll your own free .NET technical conference?

Posted On Sunday, August 5, 2012 12:00 PM | Comments (0)
Wednesday, July 4, 2012
Independence Day for Software Components – Loosening Coupling by Reducing Connascence

Today is Independence Day in the USA, which got me thinking about loosely-coupled “independent” software components.

I was reminded of a video I bookmarked quite a while ago of Jim Weirich’s “Grand Unified Theory of Software Design” talk at MountainWest RubyConf 2009. I finally watched that video this morning. I highly recommend it. In the video, Jim talks about software connascence.

The dictionary definition of connascence (con-NAY-sense) is:

1. The common birth of two or more at the same time

2. That which is born or produced with another.

3. The act of growing together.

The brief Wikipedia page about Connascent Software Components says that:

Two software components are connascent if a change in one would require the other to be modified in order to maintain the overall correctness of the system. Connascence is a way to characterize and reason about certain types of complexity in software systems.

The term was introduced to the software world in Meilir Page-Jones’ 1996 book “What Every Programmer Should Know About Object-Oriented Design”. The middle third of that book is the author’s proposed graphical notation for describing OO designs. UML became the standard about a year later, so a revised version of the book was published in 1999 as “Fundamentals of Object-Oriented Design in UML”. Weirich says that the third part of the book, in which Page-Jones introduces the concept of connascence “is worth the price of the entire book”. (The price of the entire book, by the way, is not much – I just bought a used copy on Amazon for $1.36, so that was a pretty low-risk investment. I’m looking forward to getting the book and learning about connascence from the original source.)

Meanwhile, here’s my summary of Weirich’s summary of Page-Jones writings about connascence:

The stronger the form of connascence, the more difficult and costly it is to change the elements in the relationship. Some of the connascence types, ordered from weak to strong are:

Connascence of Name

Connascence of name is when multiple components must agree on the name of an entity. If you change the name of a method or property, then you need to change all references to that method or property. Duh. Connascence of name is unavoidable, assuming your objects are actually used. My main takeaway about connascence of name is that it emphasizes the importance of giving things good names so you don’t need to go changing them later.

Connascence of Type

Connascence of type is when multiple components must agree on the type of an entity. I assume this is more of a problem for languages without compilers (especially when used in apps without tests). I know it’s an issue with evil JavaScript type coercion.

Connascence of Meaning

Connascence of meaning is when multiple components must agree on the meaning of particular values, e.g that “1” means normal customer and “2” means preferred customer. The solution to this is to use constants or enums instead of “magic” strings or numbers, which reduces the coupling by changing the connascence form from “meaning” to “name”.

Connascence of Position

Connascence of positions is when multiple components must agree on the order of values. This refers to methods with multiple parameters, e.g.:

eMailer.Send("somebody@somewhere.com", "someguy@something.org", "Your order is complete", "Order completion notification");

The more parameters there are, the stronger the connascence of position is between the component and its callers. In the example above, it’s not immediately clear when reading the code which email addresses are sender and receiver, and which of the final two strings are subject vs. body. Connascence of position could be improved to connascence of type by replacing the parameter list with a struct or class. This “introduce parameter object” refactoring might be overkill for a method with 2 parameters, but would definitely be an improvement for a method with 10 parameters.

This points out two “rules” of connascence:

    •  The Rule of Degree: The acceptability of connascence is related to the degree of its occurrence.
    • The Rule of Locality: Stronger forms of connascence are more acceptable if the elements involved are closely related. For example, positional arguments in private methods are less problematic than in public methods.

Connascence of Algorithm

Connascence of algorithm is when multiple components must agree on a particular algorithm. Be DRY – Don’t Repeat Yourself. If you have “cloned” code in multiple locations, refactor it into a common function.

 

Those are the “static” forms of connascence. There are also “dynamic” forms, including…

Connascence of Execution

Connascence of execution is when the order of execution of multiple components is important. Consumers of your class shouldn’t have to know that they have to call an .Initialize method before it’s safe to call a .DoSomething method.

Connascence of Timing

Connascence of timing is when the timing of the execution of multiple components is important. I’ll have to read up on this one when I get the book, but assume it’s largely about threading.

Connascence of Identity

Connascence of identity is when multiple components must reference the entity. The example Weirich gives is when you have two instances of the “Bob” Employee class and you call the .RaiseSalary method on one and then the .Pay method on the other does the payment use the updated salary?

 

Again, this is my summary of a summary, so please be forgiving if I misunderstood anything. Once I get/read the book, I’ll make corrections if necessary and share any other useful information I might learn.

 

See Also:

Gregory Brown: Ruby Best Practices Issue #24: Connascence as a Software Design Metric (That link is failing at the time I write this, so I had to go to the Google cache of the page.)

Posted On Wednesday, July 4, 2012 5:42 PM | Comments (0)
Sunday, July 1, 2012
Roll your own free .NET technical conference

If you can’t get to a conference, let the conference come to you! There are a ton of free recorded conference presentations online…

Microsoft TechEd

Let’s start with the proverbial 800 pound gorilla. Recent TechEds have recorded the majority of presentations and made them available online the next day.

Check out presentations from last month’s TechEd North America 2012 or last week’s TechEd Europe 2012. If you start at http://channel9.msdn.com/Events/TechEd, you can also drill down to presentations from prior years or from other regional TechEds (Australia, New Zealand, etc.)

The top presentations from my “View Queue”:

NDC

The Norwegian Developer Conference site has the most interesting presentations, in my opinion. You can find the videos from the June 2012 conference at that link. The 2011 and 2010 pages have a lot of presentations that are still relevant also.

My View Queue Top 5:

ØREDEV

Travelling on from Norway to Sweden... I don’t know why, but the Scandinavians seem to have this conference thing figured out. ØREDEV happens each November, and you can find videos here and here.

My View Queue Top 5:

aspConf - The Virtual ASP.NET Conference

Formerly known as “mvcConf”, this one’s a little different. It’s a conference that takes place completely on the web.

Check out the recordings from the conferences held:

It’s two years old and talks about ASP.NET MVC2, but most of it is still applicable, and Jimmy Bogard’s Put Your Controllers On a Diet presentation is the most useful technical talk I have ever seen.

CodeStock

Videos from the 2011 edition of this Tennessee conference are available. Presentations from last month’s 2012 conference should be available soon here.

I’m looking forward to watching Matt Honeycutt’s Build Your Own Application Framework with ASP.NET MVC 3.

UserGroup.tv

User Group.tv was founded in January of 2011 by Shawn Weisfeld, with the mission of providing User Group content online for free. You can search by date, group, speaker and category tags.

My View Queue Top 5:

Posted On Sunday, July 1, 2012 2:12 PM | Comments (2)
Saturday, June 30, 2012
St. Louis ALT.NET

I’m a huge fan of the St. Louis .NET User Group and a regular attendee of their meetings, but always wished there was a local group that discussed more advanced .NET topics. (That’s not a criticism of the group - I appreciate that they want to server developers with a broad range of skill levels).

That’s why I was thrilled when Nicholas Cloud started a St. Louis ALT.NET group in 2010. Here’s the “about us” statement from the group’s web site:

The ALT.NET community is a loosely coupled, highly cohesive group of like-minded individuals who believe that the best developers do not align themselves with platforms and languages, but with principles and ideas. In 2007, David Laribee created the term "ALT.NET" to explain this "alternative" view of the Microsoft development universe--a view that challenged the "Microsoft-only" approach to software development. He distilled his thoughts into four key developer characteristics which form the basis of the ALT.NET philosophy:

  • You're the type of developer who uses what works while keeping an eye out for a better way.
  • You reach outside the mainstream to adopt the best of any community: Open Source, Agile, Java, Ruby, etc.
  • You're not content with the status quo. Things can always be better expressed, more elegant and simple, more mutable, higher quality, etc.
  • You know tools are great, but they only take you so far. It's the principles and knowledge that really matter. The best tools are those that embed the knowledge and encourage the principles (e.g. Resharper.)

The St. Louis ALT.NET meetup group is a place where .NET developers can learn, share, and critique approaches to software development on the .NET stack. We cater to the highest common denominator, not the lowest, and want to help all St. Louis .NET developers achieve a superior level of software craftsmanship.

I don’t see a lot of ALT.NET talk in blogs these days. The movement was harmed early on by the negative attitudes of some of its early leaders, including jerk moves like the Entity Framework “vote of no confidence”, but I do see occasional mentions of local groups like the St. Louis one. I think ALT.NET has been successful at bringing some of its ideas into the .NET world, including heavily influencing ASP.NET MVC and raising the general level of software craftsmanship for developers working on the Microsoft stack. The ideas and ideals live on, they’re just not branded as “this is ALT.NET!”

In the past 18 months, St. Louis ALT.NET meetups have discussed topics like:

  • NHibernate
  • F# and other functional languages
  • AOP
  • CoffeeScript
  • “How Ruby Is Making Me a Stronger C# Developer”
  • Using rake for builds
  • CQRS
  • .NET dynamic programming
  • micro web frameworks – Nancy & Jessica
  • Git

ALT.NET doesn’t mean (to me, anyway) “alternatives to .NET”, but “alternatives for .NET”. We look at how things are done in Ruby and other languages/platforms, but always with the idea “What can I learn from this to take back to my “day job” with .NET?”.

Meetings are held at 7PM on the fourth Wednesday of each month at the offices of Professional Employment Group. PEG is located at 999 Executive Parkway (Suite 100 – lower level) in Creve Coeur (South of Olive off of Mason Road - Here's a map).

Food is not supplied (sorry if you’re a big fan of the Papa John’s Crust-Lovers’ Pizza that’s a staple of user group meetings), but attendees are encouraged to come early and bring/share beer, so that’s cool.

Thanks to Nick for organizing, and to Professional Employment Group for lending their offices.

Please visit the meetup site for more information.

Posted On Saturday, June 30, 2012 8:14 AM | Comments (0)
Saturday, April 16, 2011
Virtual Brown Bag Recap

I haven't posted a recap lately, because the Virtual Brown Bag recordings weren't being uploaded for a while. That was fixed two weeks ago, so I had a lot of meetings to catch up on. Here's an all-you-can-eat brown bag buffet…

March 3

Guest presenter Jim Christopher - creator of StudioShell, a deeply integrated PowerShell host available inside of Visual Studio 2010 and 2008.

StudioShell exposes many of Visual Studio’s extensibility points in a simple and consistent way, and it makes the Visual Studio DTE interactive and discoverable.  What an add-in does in a compiled binary, StudioShell can accomplish with a one-liner.

https://sites.google.com/site/vbbwiki/main_page/2011-03-03

March 10

Topics:

  • Options for uploading files to a Rails/MongoDB site
  • Chrome developer tools
  • George Mauer shares some useful extension methods

https://sites.google.com/site/vbbwiki/main_page/2011-03-10

March 17

Jonathan "JB" Birkholz shows off his "CodeMav" site

https://sites.google.com/site/vbbwiki/main_page/2011-03-17

March 24

Alan Stevens: "KickAss Ruby" - Rails development on Windows

https://sites.google.com/site/vbbwiki/main_page/2011-03-24

March 31

Topics:

  • Rails authentication & authorization
  • S#arp Architecure / Templify
  • Git branching

https://sites.google.com/site/vbbwiki/main_page/2011-03-31

April 7

Topics:

  • CleanCoders & code school - online video learning
  • "What the hell was I thinking?"
  • JavaScript design patterns
  • We discuss some &%$#'s blog post: "Why I don't hire .NET Programmers"

https://sites.google.com/site/vbbwiki/main_page/2011-04-07

April 14

Topics:

  • object mappers: ditto & AutoMapper
  • Mono for Android
  • Rails / web development help sites

https://sites.google.com/site/vbbwiki/main_page/2011-04-14

Posted On Saturday, April 16, 2011 7:29 PM | Comments (0)
Saturday, February 12, 2011
Virtual Brown Bag: Ruby Newbies, Mockups, There *is* an I in SOLID, fuv

At this week's Virtual Brown Bag meeting:

  • Claudio pointed us to Try Ruby! and Rails For Zombies, two sites to educate Ruby newbies
  • We looked at the free version of Balsamiq, and other online mockup sites
  • George walked us through a refactoring to isolate roles and adhere to the Interface Segregation Principle (the "I" in SOLID)
  • We laughed at fuv, the code editor for "real programmers"

For detailed notes, links, and the video recording, go to the VBB wiki page:
https://sites.google.com/site/vbbwiki/main_page/2011-02-10

Posted On Saturday, February 12, 2011 11:49 AM | Comments (0)
Sunday, January 9, 2011
Virtual Brown Bag Recap: JB's New Gem, Patterns 101, Killing VS, CodeMav

At this week's Virtual Brown Bag meeting:

  • JB showed off his new SpeakerRate Ruby gem
  • Claudio alerted us to the Refactoring Manifesto
  • We answered the question "How do I get started with Design Patterns?"
  • Ever had to kill a frozen instance of Visual Studio? Yeah, I thought so. Claudio showed us how to do it with PowerShell. (It's faster)
  • JB previewed his new CodeMav web site, which will be a social network for developers (integration with Speaker Rate, slide share, github, StackOverflow, etc.)

For detailed notes, links, and the video recording, go to the VBB wiki page:
https://sites.google.com/site/vbbwiki/main_page/2011-01-06

Posted On Sunday, January 9, 2011 7:50 AM | Comments (0)
Thursday, December 23, 2010
Virtual Brown Bag Recap: FancyHands, CanCan, 1KB XMas Tree, YouTube Yuks

At this week's Virtual Brown Bag meeting:

  • Claudio has some one-month Evernote premium accounts to give away
  • Claudio & George talked about FancyHands, the 4-hour work week, and paying people to do the stuff you don't want to
  • JB shared more Ruby gems: cancan and open and talked about insert and other Ruby Enumerable functions
  • We looked at the winner of the 1KB JavaScript Christmas contest and some fun YouTube videos

For detailed notes, links, and the video recording, go to the VBB wiki page:

https://sites.google.com/site/vbbwiki/main_page/2010-12-23

Posted On Thursday, December 23, 2010 10:38 PM | Comments (0)
Saturday, December 4, 2010
Virtual Brown Bag Recap: NuGet, PoshCode, Code Templates
Roving tuba brawl

"Virtual Brown Bag" anagrams:

  • Roving Tuba Brawl
  • Lawn Bug Vibrator
  • Rubbing Two Larva
  • Vulgar Rabbi Town
  • A Vibrant Grub Owl
  • Blurting a Bar Vow

At this week's Roving Tuba Brawl Virtual Brown Bag meeting:

  • Claudio Lassala asked "What does your work environment look like?" He and several others shared pictures.
  • George Mauer talked about NuGet, .NET's answer to Ruby Gems, and PoshCode, a PowerShell code repository
  • Claudio showed how he uses CodeRush templates to quickly generate unit test code
  • Alan Stevens showed how to do the same thing with Resharper templates

For detailed notes, links, and the video recording, go to the VBB wiki page:

https://sites.google.com/site/vbbwiki/main_page/2010-12-02

Posted On Saturday, December 4, 2010 8:50 AM | Comments (0)
Thursday, November 25, 2010
Better keyword than "await" - How about "async"?

My late contribution to a debate that was raging almost a month ago now…

Regarding the upcoming C# 5 asynchronous programming improvements, Eric Lippert blogged about how Microsoft is aware that the "async" and "await" keywords, as shown below, imply the opposite of what they really mean:

async void ArchiveDocuments(List<Url> urls)
{
  Task archive = null;
  for (int i = 0; i < urls.Count; ++i)
  {
    var document = await FetchAsync(urls[i]);
    if (archive != null)
      await archive;
    archive = ArchiveAsync(document);
  }
}
 

Regarding "await", Lippert said:

The “await” operator used twice in that method does not mean “this method now blocks the current thread until the asynchronous operation returns”. That would be making the asynchronous operation back into a synchronous operation, which is precisely what we are attempting to avoid. Rather, it means the opposite of that; it means “if the task we are awaiting has not yet completed then sign up the rest of this method as the continuation of that task, and then return to your caller immediately; the task will invoke the continuation when it completes.

It is unfortunate that people’s intuition upon first exposure regarding what the “async” and “await” contextual keywords mean is frequently the opposite of their actual meanings. Many attempts to come up with better keywords failed to find anything better. If you have ideas for a keyword or combination of keywords that is short, snappy, and gets across the correct ideas, I am happy to hear them.

My suggestion (which probably has been suggested by someone else - there was a ton of discussion on this, and it would take days to read all of it): Why not just use "async" instead of "await", e.g.:

var document = async FetchAsync(urls[i]);
 

I don't have a better suggestion for "async" for the method declaration keyword (I don't have a problem with it either). I also don't think it would be confusing to use "async" for both the method and statement keywords. We're "using" the same keyword in different contexts elsewhere in C# without confusion.

My other suggestion: Just make up a new word that doesn't imply any unwanted meaning. "asdf" is easy to type. Smile

Posted On Thursday, November 25, 2010 6:59 AM | Comments (1)
Tag Cloud