We need ALT.NET to supplement the traditional .Net leadership


One of the roles I’d like ALT.NET fulfill within the greater .Net community is to be a second pole of leadership and thought. I say a “second” pole, because the .Net community already has a long standing traditional leadership — the book authors, the MVP’s*, the INETA speakers, and whatnot. They’ve done plenty of good in regards to explaining how to best use existing and forthcoming Microsoft tools, but I think there are a lot of valuable subjects and viewpoints that are largely missing from the mainstream .Net dialogue. Specifically, I’d like to see ALT.NET start to fill what I see as a void for information and leadership on:

  • OOP fundamentals. I think we as a community would achieve far more benefits on our projects from a stronger base of OOP design knowledge than we do for learning new API’s like WCF or LINQ. Learning the fundamentals will make us far better able to choose and use these new API’s.
  • Development processes and practices. Microsoft builds and sells tools, and they naturally see tools as the solution to most problems. We the community should be completely in charge of determining our best practices because we are the ones out there building software. Go to a .Net centric development conference. Outside of some token Agile track, you will not see very much about configuration management, project management, requirements, testing, or the all important people issues. A lot of Linq to XYZ talks, but not much about running successful software projects.
  • Alternative tools. Some of the tools Microsoft makes are great, but some are inferior to non-Microsoft options. Some of these alternative tools open up entirely new possibilities in how we can work.  I’d like to see the entire .Net community to simply broaden its horizons to be more accepting of tools originating from outside of Redmond.


Two recent podcast’s illustrate to me why I think something like ALT.NET has some value to offer the community by filling holes in the dialogue.  First up was Lerman on the Entity Framework on DotNetRocks. I promised Julie that I wouldn’t burn her in effigy here, so I’ll just say that I think that podcast covered the Entity Framework from a very data centric viewpoint that skated over some important concerns about using any persistence framework.  Namely, what does this tool do to my business layer and the application as a whole?  How much does the tool intrude on the rest of the application?  From my own, very different viewpoint, the Entity Framework is conceptually flawed in some significant ways and won’t let me work in the way that *I* think makes me the most successful:

  • In my opinion the new “conceptual model” in the Entity Framework that allows you to treat the database more as a set of hierarchical entities is a poor substitute for fullblown OOP programming. I think the conceptual model is unnecessary complexity that detracts from the usability of the EF.
  • The lack of transparent “lazy loading” in the Entity Framework is a dealbreaker for me. The need to explicitly say “Order.LineItems.Load()” makes the EF a very poor fit for Test Driven Development by making the EF objects difficult or nearly impossible to use independently of the database. Lazy loading should be completely transparent to the business logic, and I should be able to completely express the business logic without letting infrastructure concerns leak in (that Separation of Concerns thing). The podcast completely whiffed on this topic in the discussion of “POCO” objects at the end of the episode.
  • At this point, EF couples you very tightly to the database. Support is very weak at this point for Domain Driven Design techniques. I really don’t think the EF is usable without using codegen to bake in the change tracking code that EF wants to be in the objects. Codegen-ing your business objects pretty well eliminates evolutionary design or keeping your domain logic in these classes. I know you can use partial classes for the business logic, but that’s sooooo clumsy. Besides, the codegen is more or less optimized for scenarios where you merely replicate the structure of the database in the object model.

Many people don’t feel that the EF picture is all that rosy, but those concerns simply aren’t getting much attention or understanding from our traditional community leadership. 

The second podcast was .Net author Rocky Lhotka being interviewed on Hanselminutes about data access issues.  I mostly agree with Rocky on the general goals, but I think there’s better mechanical ways to achieve an effective object model strategy than what Rocky was espousing on the show.  Rocky gets some serious points from me for talking about Responsibility Driven Design (my choice for the single most effective design technique) and the Single Responsibility Principle (SRP).  Ironically enough though, I advise people against using his CSLA.Net framework in no small measure because I think CSLA violates the Single Responsibility Principle.** It may be that Rocky and I have vastly different interpretations of the SRP, but that again points to the validity of a second pole of thought and discussion because I really don’t think that Rocky (or any one else including me) gets to be the sole voice who gets to define design best practices.

One of the other things Rocky said was that ORM tools tightly bind your object model to the database. His suggestion was to use an ORM as just a data access layer and manually write mapping code within your business objects to translate between the database model persisted by the ORM and your own domain model classes. I thought this was terrible advice in most situations because it’s unnecessary, and putting that mapping code inside your business objects let’s infrastructure concerns bleed into my your domain logic code (a clear SRP violation).  When I use NHibernate, I can write my business objects in a structure that fits the behavior of the business logic the way Rocky and I both want to, but I can also persist these objects to a database structure that makes sense for the database with very little impact on the business objects.  I do not have any need to write all of that tedious mapping object-to-object code that Rocky was suggesting.  I don’t know if Rocky was purposely overlooking the capabilities of NHibernate or the WilsonORMapper in favor of his traditional CSLA approach, doesn’t believe in ORM, or if he just flat out doesn’t know.  Either way, we need some alternative sources of information, and dare I say it, visible authority figures in the community.


Sometimes the Microsoft solution isn’t the best

Both podcast’s were lacking in well informed opinions about alternatives to the Microsoft tooling on data access, and I think that’s probably my biggest reason for writing this post.  If my choice was really a binary decision between Linq to SQL or Linq to Entities and rolling naked ADO.Net code, heck yes I’d jump for joy about the EF.  Fortunately for us, that’s not the case.

The biggest problem for me with the EF is that I think there are simply better existing tools for the vast majority of projects. For simpler CRUD or reporting applications, SubSonic is basically the exact same kind of “generate strongly typed object wrappers around the database tables” solution as the EF and Linq to SQL, but I bet SubSonic would be much easier to use. LLBLGen Pro is much more feature rich than the Entity Framework. NHibernate is vastly better if you want to use a rich Domain Model approach for your design and/or want to most effectively utilize TDD. iBatis.Net will probably be easier to use for nastier legacy database schemas and give you ultimate control over the SQL with lighter weight mapping than the EF. Heck, LLBLGen Pro and NHibernate are well on their way to having full LINQ support, and SubSonic has a strongly typed query language, so shoot down that advantage for EF.  My preference is NHibernate, but I was very happy with my usage of the Java version of iBatis.

I honestly believe that if we don’t have any useful alternative to the traditional .Net leadership, all of these arguably superior tools will be shoved to the sideline in favor of the deeply flawed Entity Framework. Worse yet is that we might not get better tools because I don’t think our traditional leadership does a very good job of giving useful feedback to Microsoft to help make these tools better. I really do believe that our traditional leadership largely sees new tooling as simply opportunities to write articles, books, and be visible conference speakers rather than something that needs to be carefully evaluated and possibly rejected. I want leadership that can help us make good judgements about how and with what we should build software instead of just relaying the guidance from our toolmaker.


Summing Up

I didn’t say here that I think we need to completely swap out our entire leadership clique.  All I want is an additional set of leadership types who are discussing other points of view to give us a more rounded conversation.  To some degree, I think we might just need a new generation of leadership that didn’t come up through Windows DNA programming.  Lastly, I don’t really care if it’s the ALT.NET movement specifically that starts to fill this void as long as it’s filled by somebody in a useful way.

When some .Net poobah says that every class should be accessed through WCF, someone else should speak up and say “that’s insanely stupid,” but in a reasoned, adult like manner.  And if any MVP speaker type says you should be using the Entity Framework/WF/putting all your business logic into XAML/whatever, I want to see some dissenting opinions too.

Comments are open. Feel free to disagree with me.





*To be fair, many of the most visible ALT.NET members, including myself and many other CodeBetter bloggers, are also MVP’s of one sort of another. I’d still say that we make up a very small minority of the total MVP lineup.

** To the CSLA proponents out there, I’m going to issue you a challenge. Run static code analysis numbers on your CSLA “business” objects. I’ll betcha that the Cyclomatic Complexity numbers are uncomfortably far into the dangerous zone – and yes, if this is so, this is something you should be concerned about.

About Jeremy Miller

Jeremy is the Chief Software Architect at Dovetail Software, the coolest ISV in Austin. Jeremy began his IT career writing "Shadow IT" applications to automate his engineering documentation, then wandered into software development because it looked like more fun. Jeremy is the author of the open source StructureMap tool for Dependency Injection with .Net, StoryTeller for supercharged acceptance testing in .Net, and one of the principal developers behind FubuMVC. Jeremy's thoughts on all things software can be found at The Shade Tree Developer at http://codebetter.com/jeremymiller.
This entry was posted in Featured. Bookmark the permalink. Follow any comments here with the RSS feed for this post.
  • http://www.nagarro.com/Technologies/.Net_Development.aspx .NET Development

    great post.. I am agree with you

  • http://www.e-zest.net/migrate-to-dotNET-framework3.htm Net Framework Development

    Great post…. nice thoughts…

  • http://sjancke.blogspot.com Sebastian Jancke

    Jeremy, I could not have said better – I fully agree.

    I’ve got a bunch of colleagues and friends that are fully going .net mainstream. I can tell you, that “converting” them to question their old (Microsoft) paths is really hard – confronted with a lot of ignorance and disbelieve that there could exist more and other ways in doing things.

    What’s interesting about that, is the comparison to the Java community. I won’t say, everything is fine or better there. But we have more diversity, more questioning of old paths and definitely more OO-thinking over there.

    Reason could be, it’s the wide-spread leadership there. Reason could also be, that Microsoft simply doesn’t provide enough (any?) samples showing “ALT.NET” ways and has no experience with it.

    In general, I’d say that new APIs are easier to show in guidelines, online tutorials and samples than oo-concepts and stressing out their importance (but not impossible).

  • BrianE


    I agree with you 100%. I’m was one of those 90%.

    @Jon Rowett

    I got my degree in MIS from one of the top ranked MIS programs in the country back in 2002. We barely touched on what objects and classes were. Certainly not enough to understand them well enough to do more than re-create some trival example of a point. Design Pattern? Thats what my grandma uses to make her old lady clothes right?

    Most of my friends and I got hired on at smaller non-tech companies doing internal development. Again, with no one to teach/mentor/guide us – we didn’t know any better. Plus we were MIS grads, we cared more about the business end of it anyway. Then one day we had to start maintaining the programs we wrote and we realized just how much we didn’t know.

    Google and Alt.Net to the rescue… There has been so much I have learned in the last year thanks to Alt.Net blogs, etc. AND Typical.Net blogs, etc. I think the “movement” is probably making a bigger difference than is apparent.

    Yes, I do still use the MS tools over the alternatives, but only because I’m spending so much time/energy learning the concepts. MS options tend to have better marketing, documentation, and guidance so it makes it easier to adopt. You have to remember that I’m trying to cram 2-3 years of school into a year, and oh yeah did I mention I have kids now… Once I get a better understanding of the concepts (in part because the flaws in the MS tools help to highlight the reason for them) I’ll move on to better things.

    More coverage for Alt.Net will certainly help, but I think you guys are doing a better job than you give yourself credit for. You’ll see the benefits of what your are doing today in a year or two. It takes a while to convert a mort…

  • flipdoubt


    That makes perfect sense, but what are the guidelines for how “close to the glass” (to steal Hanselman’s phrase for close to the UI) should these controllers be? How many should you have? I guess this art or craftsmanship needed to wield MVC skillfully.

  • http://codebetter.com/blogs/jeremy.miller Jeremy D. Miller


    The classes do talk to one another. Borrowing from Responsibility Driven Design, some classes can be stereotyped as “Conductors” or “Coordinators” or “Controllers.” I like to largely call the coordination of classes and services a responsibility in its own right.

  • flipdoubt

    One question that has been nagging me lately: I believe I grok the benefit of the SRP, but if all your classes are responsible for just one thing, won’t your software do just one thing? I don’t mean for that to sound overly simplistic. I’m more interested in learning where the best place is to bring all these single responsibilities together to deliver real value to the user.

  • http://graysmatter.codivation.com Justice~!

    AMEN to this post. You said a lot of stuff that I’ve had on my mind, but managed to do so far more politely than I think I will be capable of doing 😉

  • http://www.walkspoiled.com jim Bonnie

    Excellent post to get people thinking, that is not to much to ask, is it!

    The impact of ALT.Net on the mainstream .net development community and the traditional leadership is a blessing to all.

    Check out Julie’s post announcing the latest release of NHibernate, now that is great for everybody. http://www.thedatafarm.com/blog/2008/04/02/nHibernate20Alpha.aspx

    I am very happy to see this conversation and really look forward to a DotNetRocks episode on the same.
    I am also sure this will surface at the DNR Panel at Toronto’s DevTeach on the Future of Dot Net.

  • Ed

    +1 for Corey. Lack of really solid documentation for putting NHibernate to use in an at least “semi” real life application is hard to find. You have to piece stuff together, which can be a little tiresome, especially when one blog/article contradicts another. In addition, I get frustrated when I see someone say NH may is not suitable for reporting type applications, but does not explain further. Can you reliably call stored procedures or not??

  • http://blowmage.com/ Mike Moore

    Oops, found a typo. “All the mainstream languages” should be “All those mainstream languages”. My bad.

  • http://blowmage.com/ Mike Moore

    I like this post, and I wish I could have commented on it sooner. I wrote an entire blog post in response to this, but I threw it away because it sucked. Which might have something to do with my exhaustion after MountainWest RubyConf 2008… I only have two points I’d like to make:

    1) Tools – Tools are great, but they won’t make you a better programmer. I know everybody loves their tools, but it seems to me that Alt.NET is focusing too much on the cart and not enough on the horse. Which leads me to…

    2) OOP Fundamentals – I can’t agree more with the points you made about OOP fundamentals. I believe this is the #1 thing keeping .NET behind the various other communities. Unfortunately, in my mind C# and VB.NET (and Java) are not OO. Not really. They have OO features, but they miss part of the essence of what makes OO so powerful. I sincerely believe that you cannot teach OO using those languages. I’ve tried both to learn and to teach OO in those languages and it has never really worked for me. If you really want to learn OO you need to learn Ruby or Smalltalk. This is why you hear Ruby folks saying things like “Ruby made me a better C#/Java/C++ developer”, because they finally learned OO.

    I understand I may get flak for saying C# isn’t OO. Go ahead, I’m prepared for it. All the mainstream languages follow the C++ legacy of how they approach and implement OO features, and they are wrong. Adding OO features to a language does not make it OO. I think Alan Kay said it best:

    “Actually I made up the term ‘object-oriented’, and I can tell you I did not have C++ in mind.”

    I apologize for calling the emperor out, but seriously, the dude has no clothes on.

  • Corey

    Alternatives have their issues as well. Maybe not in their elegance, but rather the horrible documentation and examples that exist to ramp up on such technologies. In order for me to learn NHibernate I have to look in 50 different locations. The documentation, read blogs with code that don’t quite fit my needs, compare the Hibernate documentation, etc. Microsoft tools are popular because of their tools that make things simple for us idiots. They also have webcasts, documentation, etc. Even when Microsoft documents things poorly it is usually better than the alternatives will ever be. I don’t dispute that were we to compare NHibernate to EF that NHibernate would be able to do the job better, and more elegant without question. But for the average Joe would they be able to grasp NHibernate over EF in the amount of time it takes for them to hit their deadlines? So from someone that typically leans towards the Microsoft tools, but always striving for better alternatives I am equally frustrated.

  • http://codebetter.com/blogs/jeremy.miller Jeremy D. Miller


    The EF and Rocky/CSLA (to a smaller degree) are just examples of topics where I think ALT.NET could add value by telling other viewpoints and opinions.

    BTW, is this the real “I am Spartacus/Pursefight” Bil Simser, or just a cheap wannabe?

  • http://weblogs.asp.net/bsimser Bil Simser


    I’m confused over this post. It starts with a call for supplementing alternate leadership in ALT.NET (to paraphrase) but then we get into a EF and CSLA discussion?

    I’ll agree. EF just makes me run and scream. Explicit load calls just don’t do it for me as I want my OR/M to be there when I need it, but not in a “inyerface” mode. Having to toss away your domain model as so many demos have shown and tying yourself to the data model is so old school to me (and not in a good retro David Laribee way). I’m taking the stance to *not* learn or continue my advancement of learning the EF as it just doesn’t work for me in any capacity. I can be 10x more productive with NHibernate without polluting my domain.

    As for CSLA, Rocky has his ways and while I respect them I don’t agree with the model CSLA uses. I’m not a fan of AR in general and like you said, even with abstractions (leaky at best) you’re still tying the business layer to the data layer and everything in CSLA is very data centric. It’s not different than generating your DAL with nTiers or LLL and building a system around it. That’s flawed IMHO much like you wouldn’t build a castle on a swamp (although many have tried).

    For the leadership aspect (and how this lines up to the tools discussion) I’ll agree on the OO principals. The ALT.NET list(s) has just been too overwhelming for me lately to participate in so I’m out of tune with the discussions and only take part in a cursorary way when something jumps out.

    We do need to get back to basics and understandings of what ALT.NET is about (good software development and design) and focus on that, no matter who’s leading the charge (and frankly I don’t really care for a leadership mentality, I would rather subscribe to a flock approach where the group follows a thread or idea until it starts losing value). The discussions on the DDD mailing list and the recent NHibernate users list have both been pretty good (even though they’re specific) and the type of discussions I would like to see foster and grow in the ALT.NET community.

    Definately something to bring up at the open spaces conference coming up.

  • Scott Wojan

    Jeremy, I can’t agree more with you. I’ve been using NHibernate for about 3 years now and NOTHING comes close to it. I cannot understand why Microsoft refuses to embrace existing tools from the open source community, choosing instead to implement their own flawed and often platform skewed versions from scratch. First and foremost, I wish they would stop developing stuff for the lowest common denominator. RAD application development only works WELL for the smallest of small projects and really *neat* presentations. LINQ to SQL is another *neat* presentation tool and should only be used on a tiny project. The entity framework is has all the flaws you have pointed out as well as being product and platform centric. Microsoft could have greatly contributed to the NHibernate project and given their audience the same functionality using a flexible, proven tool that is NOT platform centric.

  • Jon Rowett

    as someone without a degree, please remind me: what exactly do they teach on computing courses at university these days?

  • http://kg2v.blogspot.com/2008/04/altnet-leadership-to-suppliment.html KG2V

    Pingback from KG2V. I totally agree. I also agree that the biggest weakness I see is lack of OOP, particularly the folks coming from Visual Basic (hand raised – been a VB jock since 1.0). I was with a group that did “objects” as best as we could with VB 4,5,6, and boy what a difference you can have with .NET. I look back at my code from .NET 1.0 and the like, and I shake my head

  • http://lazycoder.com Scott

    I’ve been following .NET since Sept. 2000 when it was announced at PDC. I knew about it when it was still called NGWS and ASP+. I’ve read a lot of book, blogs and seen a lot of presentations on .NET. ALT.NET and straight from the MS fire hose of MSDN.

    Hand to God, this is the first time I’ve heard of CSLA. I have never seen in implemented nor seen a presentation or blog post on it . I don’t know what that makes me, but I’m sure there’s a name for it.

    So, and this is a topic I hope gets brought up in Seattle, when people talk about NHibernate, IOC, DI, TDD, BDD, DDD I feel like it’s a little too advanced for 90% of the developers I’ve encountered. It could be just in the way the technologies are presented or the assumption of the common vocabulary(jargon). I am literally telling people about indexes in SQL Server for the first time. They have a vague notion of what an object is. They equate objects directly with classes and aren’t really sure how inheritance works. Some of them are willfully ignorant, but some just really haven’t taken the time to learn about these things or don’t know where to look.

    Where do you start with OOP? With Domain design? How can you show someone how just basic unit testing can give them more confidence when they consider UAT to be a luxury done only after coding has stopped and the app has been delivered to the users?

  • http://blog.magenic.com/blogs/aarone Aaron Erickson

    Well – I can’t say that CSLA per se is completely unpopular in alt.net circles… I was at the last Chicago alt.net meeting (guess that means I *am* part of it…), and nobody had really *horrible* things to say about it… but then again, most of the people know there that a.) I am a CSLA contributor and b.) I was buying drinks … so who knows :)

    As an academic matter though, CSLA classes generally keep their data logic in one place. It just so happens that the place is about 5-6 methods that most CSLA classes have. I suppose that the lack of an encapsulation boundary around that can allow people to do stupid things, fact is that it is seldom an issue in practice.

    That said, I (speaking personally) would love to see better modularity around CSLA – particularly moving out the data access so that, at the very least, I can stop my quixotic campaign to get more people to think “CSLA is cool again”. Who knows… can’t promise anything, but given that CSLA is one of the larger and older non-MS frameworks in .NET land, I definitely think the effort to move it forward is worth it.

  • http://www.dotnettricks.com/ craig


    I have to agree with you on the CSLA thing as well. I disliked it because my domain objects kept getting cluttered with both data access code and mapping code (take a reader, convert its fields and saturate domain objects, rinse, repeat…) That was years ago, but it left a bad taste in my mouth.

    I also don’t understand those who espouse using another set of objects with a mapper (sorry to pick on you Aaron.) Someone suggested that i do that with NetTiers but that seems like a lot of duplication. I expect i would be with a CSLA + NHibernate combo as well.


  • http://codebetter.com/blogs/jeremy.miller Jeremy D. Miller


    I really can’t speak for everyone else, but I would guess that CSLA isn’t popular in ALT.NET circles because it isn’t TDD/BDD or really even DDD friendly. From my viewpoint, I’m a big believer in Agile methods like TDD and evolutionary design (which really requires TDD to be safe). Successful Agile development from a software engineering point of view requires a strong focus on Orthogonality in the code. CSLA isn’t attractive to me because it isn’t well structured to make TDD efficient. The combination of so many different infrastructure concerns plus business logic into the CSLA entity classes would be a serious drag on productivity for me. I think CSLA really needs to be rethought in terms of how it distributes responsibilities, as in don’t put everything and the kitchen sink into the entity objects.

    I get that you could use CSLA with NHibernate, but I think the *way* Rocky was recommending using the two tools together isn’t the best way. I definitely don’t want my business objects getting bogged down in noisy data conversion code.

    I saw what Nermin was doing (and did respond to an email request for help, btw), but you just shouldn’t have to use techniques like that just to write unit tests on business logic. It’s faster to write unit tests when I can just set up the domain object I want instead of having to mock the data source first.

  • http://codebetter.com/blogs/jeremy.miller Jeremy D. Miller

    @Jon Rowett,

    I consider partial classes to be a necessary evil that you only use when there’s no other choice. I really don’t like having to CTRL-TAB back and forth between two files. I think it’s easier to understand a class if it’s all in one place. Especially with Domain Model classes, I want the properties and business logic methods in the same file. That’s all.

  • http://www.flux88.com Ben Scheirman

    After talking to the EF team personally I felt that they really didn’t care as much about the DDD approach to building these apps. They kept mentioning their large enterprise customers that already have a database.

    While I’m sure they exist, they aren’t the only ones out there. They assured me that v2 will likely have a pure POCO implementation, but we’ll see how it goes.

    I totally agree with you on the lazy loading.

    Another thing I keep hearing is support for reporting. This is an area where NH (and probably other) frameworks might need work… or it might be that they can completely ignore it, leaving it to ADO.NET to handle humongous resultsets. Time will tell.

  • Jon Rowett


    *shudder* you reminded me of a job interview i had where a Java guy with a chip on his shoulder told me that “Java has more libraries and they’re just better”. (exact words)

  • http://weblogs.asp.net/fbouma FransBouma

    @jeremy: np

    @andy: well, YMMV, but here in the Netherlands, IF people go to usergroups (so the people are already more interested in what’s going on than the vast majority), they still live more or less within the safe boundaries of what MS provides them.

    Next time do a simple test: ask a couple of random developers how big they think the java world is compared to the .net world and how much software there is in the java world compared to the .net world. 10 to 1 they’ll say java is pretty limited. While the opposite is true.

  • Bill Campbell

    Oh – can’t wait to see your and Dave’s video!! You guys (and most of the codebetter folks) are at the top of my Sharp Reader list!!

  • Bill Campbell

    Excellent article! A few years back I was on a “web cast a day keeps the mind churning” and then we all started to convert from VB6 procedural stuff to OO. How I wish there was more demonstrations using OO. Think was a boost that would be to the community. All the videos that Jean-Paul has done have totally opened my eyes to a whole new world. I’m yearning for more all the time. We all want to do more than point and click. I’m trying to think of the last webcast I watched from MS that showed any OO at all – oh wait, there were some TDD/pair programming ones but that was about it.

  • http://www.peterritchie.com/blog Peter Ritchie

    People need to recognize that so-called “best practices” and technologies are situationally specific strategies, and they should understand where they do and where they don’t fit. Most patterns (even those espoused by ALT.NETters) are situationally specific strategies; sometimes they fit, sometimes they don’t.

    It’s not a software-industry-specific problem; people have a tendency to get into a comfortable rut. It’s an uphill battle to get some people to think and continuously learn and improve.

    It works the other way around too; people need to recognize that opinions on certain situationally specific strategies need to be evaluated to their situation. Having a “that vendor or us” stance is not healthy.

    Agile espouses improvement through evolution and you have to recognize that any one release of a technology or software can’t be perfect for every situation but that also means it’s not imperfect for every situation.

  • http://www.dotnettricks.com/ Craig


    Couldn’t agree more. I just did a presentation at the Fort Worth User Group and did a show of hands. Many people had not even heard of NHibernate, and only a handful were using any kind of O/R Mapping tool. This is just a guess but I bet that means that many are not even aware of ALT.NET tools and probably less than half are doing any real object orientation.

    Its always puzzled me as C#, VB.NET and the framework itself are all very OO, but the concept eludes most developers i’ve met.

    I didn’t ask about things like Subversion, Nant, DDD, etc.


  • Jon Rowett

    @ jeremy:

    great article, i agree entirely etc. one question:

    > I know you can use partial classes for the business logic, but that’s sooooo clumsy

    please could you elaborate on this point a little?

    @ Andy Miller:

    i too would be surprised to find people at user groups who weren’t already aware of open source ORMs etc. however on your average shop floor, it still holds true that most devs have zero awareness of non-redmond tooling.

  • http://blog.magenic.com/blogs/aarone Aaron Erickson

    I think it is important to separate what Rocky’s opinions are about ORM and what CSLA actually does. CSLA does not stop you, and in fact, many people in fact use NHibernate and similar tools with CSLA.

    First, there is nothing that would stop you, in theory, from using DI with CSLA in order to inject how your CSLA objects are going to handle data. A colleague of mine, Nermin Dibek, has gone down this route with a good measure of success.

    However, that said, most people don’t do it because while CSLA doesn’t outwardly support DI, it does localize data access code to the DataPortal methods. I have never heard of someone getting confused about where the data access code is with regard to CSLA objects – though I will of course admit that the structure does promote mixing of DAL code with business code, in the technical sense that they exist in the same class.

    However, that aside, my real question is why is it not the case that CSLA itself is considered alt.net? It clearly isn’t a Microsoft product, and Rocky clearly does not charge money for it. Like many other alt.net projects, it stands under constant threat of being made irrelevant by Microsoft in whatever vNext they have out for .NET. I don’t say this to be incindiary… I really am curious.

  • http://codebetter.com/blogs/jeremy.miller Jeremy D. Miller


    Laribee & I are recording an episode tomorrow morning. Just wait and see the hate mail that we get.

  • http://codebetter.com/blogs/jeremy.miller Jeremy D. Miller


    My apologies on the spelling. Fixed.


    I didn’t mean to say that this is an either/or choice of OOP or API talks. But we could do a better ratio than 95% API talks like it is today. Hitting fundamentals during those other talks would be nice.

  • Torkel

    This was a great post, and is expressing a lot of the frustration about what I also feel is missing in the mainstream .NET dialogue. Take ASP.NET MVC that is the rave now in a lot of .NET blogs, seldom is the stable and feature rich MonoRail framework mentioned.

  • http://structured-solutions.net Andy Miller


    “They have no clue there’s a world outside MS which is far bigger than their own.”

    There it is again. Where did this meme come from?

    I regularly participate in the Portland Area Dot Net User Group (PADNUG). I’m certain that nearly everyone there is aware of alternatives, even if they don’t use them every day. I’d even go so far as to say that most have evaluated alternatives…probably on their own time.

    At the same time, we (I think I speak for the majority) appreciate the money and effort that Microsoft and individual Microsoft employees invest in helping our group improve our understanding of ORM, DI, MVP, MVC, etc. AND everyone in the room is mature enough to recognize that MS presents MS approaches to those concepts (duh).

    That doesn’t mean we kowtow to MS. We welcome all points of view. I hope you and Jeremy make it by someday to present.

  • Ian Cooper

    @Don I agree that it is important to recognize that we can talk about OO best practices alongside the MS technologies. That is what I am trying to do in my Architecting LINQ To SQL series for example – show how to leverage the experience of folks using ORMs like NHibernate and WORM to work effectively with these new tools. But I agree with Jeremy that this also means pointing out where these tools fail to hit the bar we are after, like LINQ To Entities. But we do need to be promote non-MS tools where they have advantages over MS tools.

    @Frans I agree that the fundamental problem is to shift people from a ‘gospel according to MS’ approach to be more open-minded to best influences from across the development community. That is the heart of the ALT.NET movement for me.

  • http://weblogs.asp.net/fbouma FransBouma

    I know the name isn’t the greatest name of all time but it’s with 3 L’s : LLBLGen 😉

    I agree that there should be more than just the bookwriter / speaker guild to lead a stream of thoughts/ideas in the .NET community, though I think it won’t work that well to cram all those different (perhaps orthogonal) stream of thoughts/ideas into one main stream and call it alt.net: what if there are 2 or more distinctive thoughts on how you should write your software? I think it’s a bit hard to let that fall in the category of ‘alt.net’, because it weakens where alt.net stands for (a specific stream of thoughts/ideas) and it’s perhaps better to have multiple groups.

    Though the general idea that MS isn’t the only one who owns a stream of thoughts/ideas about how to write software and what to use to accomplish goals is a good start: the vast majority hasn’t even accepted THAT idea in the first place. I mean: go to a random user group, talk to some developers there and you’ll likely learn that they’re amazed how great linq to sql is because they never knew data-access could be … object oriented… :) They have no clue there’s a world outside MS which is far bigger than their own.

  • http://www.elegantcode.com Jarod

    How would alt.net go about fulfilling this role? Any ideas on what this second-pole would look like?

  • http://www.donxml.com Don Demsak

    Why can’t we do both? Talk about LINQ to XYZ and within the talk using things like NUnit, TestDriven.Net and Resharper within the API talk to show how to implement things like SRP and other good design patterns. This way, you can convert the folks that attend the typical API sessions, without having to get them to attend a session on OOP fundamentals. IMHO, it is the best of both worlds. Sure, it is a bit harder for the presenter, because they not only have to be knowledgeable in good OOP, but they need to know the API they are presenting on too. I don’t see it as a either or issue. We should always be discussing good programming habits in our talks, regardless of the API we are discussing.

  • http://dotnet.agilekiwi.com John Rusk

    Well said

  • Jeff

    Jeremy – We’ve been using CSLA for about a year now & are now considering going with a different approach for our business objects & data access layer. We also would like to get deeper into TDD & have been doing begginer-level unit testing up to this point. Have you created, or do you know of any well written sample applications that we could refer to for guidance on topics you’re refering to in this post?

    One concern of mine is that we’re currently not abstracting our layers appropriately & are coupling them too tightly – and feels like it is causing it to be more difficult to create unit tests against. I’ve read a lot of advice & tips from blogs on this, but would love to find a sample application that could put the pieces together, documented/commented as to why the code were written the way they were (the sample apps I’ve seen so far show how things were was done, but not why), and written in such a way that it could be used as patterns & a model for writing our own applications.

    Something like this would be very valuable for intermediate developers like myself.

  • http://wolfbyte-net.blogspot.com Mike Minutillo

    Rocky’s interview on Hanselminutes was interesting for me as I had just finished reading Expert C# 2005 Business Objects. It was interesting to read the book and hear the arguments from a different point of view as I have been listening solely to the ALT.NET crowd for some time now. Whilst reading/listening I was able to formulate arguments against (and for) many of the major points and I was able to see where my understanding of a topic was perhaps weak (if I didn’t haqve a good argument either way).

    This is the power of ALT.NET. Rather than saying “you are doing it the wrong way idiots! Use NHibernate or spend eternity in ADO.NET purgatory”, you get to say “well that doesn’t seem right. What if we tried it this way?”.

    I encourage people to keep up the discussion but that means listening to both sides and making a rational choice.

  • http://www.elegantcode.com Chris Brandsma

    Sounds like you need to get on DotNetRocks. I am serious about that btw. If you don’t, some second rate scoundrel – like me – will end up doing it and ruin everything. If that doesn’t work, I’ll interview you for the Elegant Code Podcast.

    So if you don’t tell me otherwise, I’m going to ping Carl Franklin. (chris.brandsmaATgmailcom)

    I was just thinking, Scott Hanselman just had on Dave Laribee

  • http://devlicio.us/blogs/sergio_pereira/default.aspx Sergio Pereira

    As you well said, the root problem here is the centralization of everything in .Net development. One polarizing tool vendor (guess who), one speaker’s association, one certification source, one … well.. enough.
    Let there be choices, let there be discussions about the choices, let there be analytical disagreement too.

  • http://davesquared.blogspot.com David

    I can’t help but think all 3 of your ALT.NET aims (OOP, dev processes and practices, and alternative tools) could be accomplished by a having a number of ALT.NET people working on an OSS, VS.NET alternative :-) They could demonstrate OOP, effective processes and practices, and would provide integration with both mainstream and alternative tools, as well as *being* a viable alternative.

    Ayende could probably finish most of it in a couple of hours, and the rest of the ALT.NET group could finish it off and blog / post messages to the group about it.

    I am almost completely joking :-)

  • http://devlicio.us/blogs/derik_whittaker/default.aspx Derik Whittaker


    I was on a CSLA project a while back and I DID run an C.C. anaylisis on the project. It was NOT a pretty picture.