News

Archives

• June 2016 (1)
• May 2016 (1)
• April 2016 (1)
• March 2016 (2)
• February 2016 (2)
• January 2016 (1)
• November 2015 (1)
• September 2015 (1)
• August 2015 (3)
• July 2015 (1)
• June 2015 (1)
• April 2015 (1)
• March 2015 (2)
• January 2015 (1)
• December 2014 (3)
• October 2014 (2)
• September 2014 (3)
• June 2014 (1)
• April 2014 (2)
• March 2014 (1)
• February 2014 (4)
• January 2014 (3)
• December 2013 (2)
• November 2013 (2)
• August 2013 (3)
• July 2013 (1)
• June 2013 (2)
• January 2013 (1)
• December 2012 (6)
• November 2012 (2)
• October 2012 (2)
• July 2012 (1)
• June 2012 (1)
• May 2012 (1)
• April 2012 (1)
• March 2012 (1)
• December 2011 (3)
• September 2011 (1)
• August 2011 (4)
• July 2011 (1)
• June 2011 (2)
• March 2011 (1)
• November 2010 (1)
• July 2010 (3)
• June 2010 (5)
• May 2010 (2)
• April 2010 (1)
• March 2010 (2)
• February 2010 (1)
• December 2009 (1)
• November 2009 (1)
• October 2009 (2)
• September 2009 (1)
• June 2009 (1)
• May 2009 (2)
• December 2008 (3)
• November 2008 (1)
• May 2008 (1)
• April 2008 (2)
• January 2008 (1)
• November 2007 (1)
• February 2007 (1)
• January 2007 (1)
• October 2006 (1)
• September 2006 (1)
• August 2006 (1)
• July 2006 (1)
• June 2006 (2)
• May 2006 (4)
• April 2006 (3)
• March 2006 (1)
• February 2006 (3)
• January 2006 (3)
• December 2005 (2)
• November 2005 (1)

Post Categories

• ASP.net
• ASP.net MVC
• Otros
• NHibernate

Image Galleries

• 

  July 2010 Entries

  Fault Injection Done Right

  Patrick Smacchia has shared his thoughts why 100% test coverage is a desirable thing to have. You can test 80% of your code quite easy but the edge cases are the hard ones which take 80% of the time to write good tests for them. Patrick claims that it is worth the effort since in the last 20% you will find most of your bugs. Why is it so hard to get to full coverage? To make the corner cases testable you need some extra ugly constructs in your product (normally via ifdefs where you throw an exception). ......

  • Share This Post:
  • 
  • 
  • 
  •   Short Url: http://wblo.gs/agC

  Posted On Monday, July 19, 2010 9:42 AM | Comments (2)
  
  
  Parsing A Text File with F#

  F# is a powerful language. When you start with functional programming you find it hard to write truly functional code. After all you have thought in imperative terms like for, foreach, while, do while, …. Mark Pearl has provided a little sample how to parse a text file with F# to count the error and warnings inside it. I think it can be more functional. Here is my try: #light open System open System.IO let lineSequence(file) = let reader = File.OpenText(file) Seq.unfold(fun line -> if line = null ......

  • Share This Post:
  • 
  • 
  • 
  •   Short Url: http://wblo.gs/acm

  Posted On Tuesday, July 6, 2010 11:10 AM | Comments (1)
  
  
  How To Break The CLR For A Cool Feature

  Did you ever want a feature but the system got in your way? In my case I wanted to to get the last thrown exception outside of any catch block. Be warned that this is a deep dive into the guts of the Common Language Runtime. Language architects and Api designers should stop reading from here on. Yes I did break the rules of encapsulation and many other things. I am perfectly fine with a reputation to use Apis in not intended ways but otherwise it would have been impossible create a tracing library ......

  • Share This Post:
  • 
  • 
  • 
  •   Short Url: http://wblo.gs/acL

  Posted On Sunday, July 4, 2010 6:11 AM | Comments (8)