﻿<?xml version="1.0" encoding="utf-8"?><rss version="2.0"><channel><title>Ayende @ Rahien</title><link>http://ayende.com</link><description>Ayende @ Rahien</description><copyright>Copyright (C) Ayende Rahien  2004 - 2021 (c) 2026</copyright><ttl>60</ttl><item><title>Xavier commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>I think, they read your comment Ayende, because the post changed and is now using parameter!
  
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment84</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment84</guid><pubDate>Tue, 31 Aug 2010 13:27:38 GMT</pubDate></item><item><title>Mitch Labrador commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>Darn we all sound like the old guy in the block that does not want kids running around in the neighborhood making all that noise, so we move into a kids free 55+ community.
  
  
Point is that these developers exist, and they will write code. They will make stupid mistakes, like we all did when we first started out, and they will *THROUGH PERSONAL EXPERIENCE* learn why DI and TDD and Separation of concerns, etc. are important principles.
  
  
Stop with the personal attacks and have a logical meaningful discussion. It we can't do that without personal attacks how can we call ourselves professionals?
  
  
@Ayende taking Erik's code out of context completely killed your credibility in this post. And then your weak defense was just .... well, lacking :)
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment83</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment83</guid><pubDate>Tue, 10 Aug 2010 14:00:50 GMT</pubDate></item><item><title>Ayende Rahien commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>Terry,
  
Take a look at the history of OR Mappers in this blog.
  
I talk about this frequently.
  
See these posts in particular:
  
  
[ayende.com/.../...rchitecture-makes-me-flinch.aspx](http://ayende.com/Blog/archive/2010/02/06/traditional-architecture-makes-me-flinch.aspx)  
[ayende.com/.../...-generic-approach-will-fail.aspx](http://ayende.com/Blog/archive/2010/08/06/data-access-is-contextual-a-generic-approach-will-fail.aspx)  
[ayende.com/.../the-stripper-pattern.aspx](http://ayende.com/Blog/archive/2009/05/14/the-stripper-pattern.aspx)  
[ayende.com/.../...-castrate-your-architecture.aspx](http://ayende.com/Blog/archive/2009/07/21/donrsquot-castrate-your-architecture.aspx)  
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment82</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment82</guid><pubDate>Mon, 09 Aug 2010 16:10:33 GMT</pubDate></item><item><title>Terry commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>@Ayende
  
  
Can I ask why?  A lot of people seem to like it, now does that make it right no.  But I am curious to hear your thoughts.
  
  
Do you have a good example of a DAL?
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment81</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment81</guid><pubDate>Mon, 09 Aug 2010 16:00:53 GMT</pubDate></item><item><title>Alex Simkin commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>@Ayende
  
  
People seem to like it :). The latest comments from May 2010 ask "Can we have the code generation template of your Data Access Layer?".
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment80</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment80</guid><pubDate>Mon, 09 Aug 2010 15:57:25 GMT</pubDate></item><item><title>Ayende Rahien commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>Terry,
  
I assume it is a joke.
  
I had a stroke when seeing the code and architecture there
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment79</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment79</guid><pubDate>Mon, 09 Aug 2010 15:26:15 GMT</pubDate></item><item><title>Anonymous commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>The atrocious comments on this page are a perfect testament to the incredible ignorance of the asp.net web development community. You all want to top each others intellect  but most of you can't even tie your F.....G shoes without help. 
  
  
You can barely read, can't spell to save your life, know nothing about the world and can't communicate two sentences without sounding like a moron or a buffoon.
  
  
The problem is not the inline code for data access in WebMatrix which you could easily move to a class file, rather the pandemic  of ignorance you have created with your personality, attitude, lack of morals and lack of manners. 
  
  
George Carlin put it right when he said that in the U.S. it is like this:
  
  
-------------------------------------------
  
"Garbage in, garbage out"
  
-------------------------------------------
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment78</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment78</guid><pubDate>Mon, 09 Aug 2010 01:30:07 GMT</pubDate></item><item><title>reboltutorial commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>I think professionals are always afraid to lose their bread and butter when programming becomes easier. 
  
  
Look at Google Android App Inventor, well why Microsoft wouldn't do the same ? Target the mass.
  
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment77</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment77</guid><pubDate>Sat, 07 Aug 2010 09:58:15 GMT</pubDate></item><item><title>Daniel marbach commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>Now I know where all the new fluff of .net was heading. Dynamic typing, prarallel extensions etc and all for: 
  
  
*trommelwirbel*
  
  
Microsoft.data
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment76</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment76</guid><pubDate>Fri, 06 Aug 2010 22:14:18 GMT</pubDate></item><item><title>Ray commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>I get the sense that this is akin to Smith &amp; Wesson developing and releasing a new model of gun in which its easier to shoot yourself in the foot. (Given that someone is going to shoot themselves in the foot, how can we make doing it easier?)
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment75</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment75</guid><pubDate>Thu, 05 Aug 2010 13:19:01 GMT</pubDate></item><item><title>Diego Rojas commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>That is why is important to know what is the difference between a coder and a programmer. Besides, most of the bad practices you found out are because of Microsoft choices about letting the platform become more "accesible" for more people. Same happens in WCF, it is so powerfull framework, but provided with basic - fit all - templates, that most WCF implementations have bad perfomance and low security, because many coders got their hands on it, and never had 5 mins to improve their services.
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment74</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment74</guid><pubDate>Wed, 04 Aug 2010 22:46:09 GMT</pubDate></item><item><title>Dave Swersky commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>I don't normally jump into the middle of a storm like this, but I can't help myself with this one.
  
  
My three cents:
  
  
1.  I agree that Microsoft's intentions are good, but also agree that they are misguided.
  
2.  I believe these intentions are misguided because they are targeting a group that *does not exist.*
  
3.  I base my assertion that the audience for this library does not exist on Eric Nelson's comment above: 
  
  
"It is intended for the women I know who runs a rugby website for her local team, it is intended for my friend who is a chemist but wanted to gather some data on a web page from colleagues, it is intended for my son to create a page that does something just a little more than HTML. "
  
  
Where to start with this comment?  I can't imagine how anyone who knows programming would expect rugby moms and hairdressers to learn enough about variables, flow control, inheritance, SQL language... just to get started.  There are already hundreds, if not thousands, of web-based point-and-click brochureware website solutions online.  Eric, do you honestly think the rugby moms will turn to Microsoft.Data before those?
  
  
I also take exception to the use of bad code for ANY example.  There is just no reason at all to use crappy code "just for demonstration purposes."  It's irresponsible and lazy.  
  
  
Bravo to Microsoft for attempting to expand the audience for programming in general.  Boo for a bungled, poorly promoted, misaligned, badly branded execution.
  
  
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment73</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment73</guid><pubDate>Wed, 04 Aug 2010 18:04:43 GMT</pubDate></item><item><title>tobi commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>@Set: rofl? Is this a joke or real? Webmatrix is like WinFS at it seems ;-)
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment72</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment72</guid><pubDate>Wed, 04 Aug 2010 15:07:50 GMT</pubDate></item><item><title>Jonathan Allen commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>@Damien Guard 
  
  
I certainly agree with you on the other benefits of using parameters in SQL.
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment71</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment71</guid><pubDate>Tue, 03 Aug 2010 23:52:21 GMT</pubDate></item><item><title>Steve Gentile commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>Web Monkey - I'd agree that webforms was a cause of much woe.  It's a pain to work with outside of a simple demo app - it's call to 'RAD' made it quickly easy to build crappy web apps - and the ajax attempts just bolted on more abstract and more painful to sift through code.
  
  
So I would agree that webforms probably pushed more asp devs away from .net.
  
  
If I was to talk to a php or web developer I'd be much more inclined to show them asp.net mvc vs. webforms.  
  
  
If you hop out of the MS world for a few minutes, you quickly see all the big name frameworks are all mvc and using the same basic principles.  Django, RoR, even the php zendframework.  So, asp.net mvc is a step in the right direction.  (although all of those I listed can run anywhere - asp.net can't - as I said before).
  
  
It's took Microsoft quite awhile to see they needed mvc - I was using Monorails before it and it was so much better than webforms.
  
  
But again, it's not the language - it's not even the framework - it's simple - for $6.95 I can get a php site up and running with mysql and practically unlimited bandwidth.  Apache on Linux wins every time for the php crowd we're discussing.
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment70</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment70</guid><pubDate>Tue, 03 Aug 2010 23:19:34 GMT</pubDate></item><item><title>Ayende Rahien commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>Web Monkey,
  
Actually, not at all. That isn't how modern PHP apps are written.
  
Concerns such as security, caching, etc are common in the PHP world. 
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment69</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment69</guid><pubDate>Tue, 03 Aug 2010 23:15:11 GMT</pubDate></item><item><title>Steve Gentile commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>I think there is a fundamental reason why we have php developers. 
  
  
1. php was rather easy to grasp - in the same vein as classic asp
  
2. the hosting is dirt cheap and runs on ISP's using Linux that is dirt cheap
  
  
Changing .net language and introducing 'simplier' constructs doesn't really address the core of #2.  
  
  
Allow php to run on Windows does solve #2 either.
  
  
I don't think the real argument is PHP devs need simplier asp.net.  I don't think 'wordpress' and 'phpnuke' and those php solutions were built by developers not capable of writing asp.net.
  
  
I propose if your asp.net could run on Apache without mono (ie. my host won't install it anyway - I tried), then you'd have more adopters.
  
  
Most of these LAMP guys do it because it's cheap and it runs anyway. 
  
  
So, rather than keep delivering 'webmatrix', 'microsoft.data' and 'lightswitch' - let's start talking in earnest about running Visual Studio outside of Windows and deploying .net apps outside of Windows.
  
  
Then you'll get the crowd you must be seeking.
  
  
I strongly believe if I could, ie. develop with VS on a Mac/Linux/Windows box (not in VM), deploy directly to Apache - this would be lightyears ahead of trying to 'dumb down' the development tools.  
  
  
I'd argue as well that MS has some of the simpliest and easiest to use tools now without needing to write sql select statements inside of a web page.
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment68</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment68</guid><pubDate>Tue, 03 Aug 2010 22:58:31 GMT</pubDate></item><item><title>tobi commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>Web Monkey, eat your bananas. We are driving porsches meanwhile.
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment67</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment67</guid><pubDate>Tue, 03 Aug 2010 22:29:08 GMT</pubDate></item><item><title>Web Monkey commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>There's really nothing wrong with the code in this post.  If you come from the PHP side of things, THIS is how things are done each and every day and how even big applications are built.  People in that universe don't spend hours trying to create a monstrous Entity Framework model just so they can get one freakin record out of a database.   There's a reason classic ASP was on par with PHP then it fell way behind once the .NET complexities started creeping-in and piling-up.  Microsoft is finally recognizing that when it comes to web dev simplicity wins, period.  
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment66</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment66</guid><pubDate>Tue, 03 Aug 2010 21:50:11 GMT</pubDate></item><item><title>Scott commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>With all the negative comments around the apparent weaknesses in the code example I decided to write a more "enterprise like" implementation of the raw ADO.Net example for reference, and post it on my blog here:
  
  
[h30507.www3.hp.com/.../81821](http://h30507.www3.hp.com/t5/The-Watering-Can-of-Enterprise/IDE-Doing-Enterprise-Software-Development-Visual-Studio/ba-p/81821)</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment65</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment65</guid><pubDate>Tue, 03 Aug 2010 20:40:20 GMT</pubDate></item><item><title>Manoj Waikar commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>C'mon guys, MS .Net ecosystem is losing so many developers to more worthy platforms (RoR) and languages (Ruby, Clojure) etc. MS has to try its best to poach developers from other platforms. And it can't dare to think of converting RoR or Clojure developers to .Net, so this is what they've stooped to; pathetic.
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment64</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment64</guid><pubDate>Tue, 03 Aug 2010 19:49:30 GMT</pubDate></item><item><title>Simon MacArthur commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>I see both sides of the coin here...
  
  
.. but playing devils advocate:
  
  
Whilst we should be professional and aim for a good solution, we are all guilty of "over valuing" code.
  
  
We take onboard the current best practises, implement them to the best of our ability, then get dumped on from a great height as the underlying concepts become taboo. This seriously brings into question the "Maintainability vs Code Depreciation" equation.
  
  
We live in a disposable society, stuff like this enables throw away code.. IMO not necessarily a bad thing, you don't buy a newspaper that will last a millenium, in the same way you don't buy a car that is obsolete tomorrow!
  
  
For those of us old enough to remember, we spent years pondering the best way to future proof COM apps, carefully crafting interfaces, building layers of abstraction all in the pursuit of an elegant LONG LIVED solution. Do we continue to ensure those apps work? Sure.
  
  
Do we at some point just scrap them, and with the DOMAIN KNOWLEDGE gained rewrite them in far less time than we did originally, using some .NET / Java /  RoR / ____  tools? 
  
  
My feeling is I don't think computer science has yet  modelled the "real world" correctly (will it ever?), and as such we are still hunting round, bouncing from idea to idea, framework to framework.  
  
  
Personally I'd like to see lifecycle management of objects  (I'm talking realtime cradle to grave stuff here rather than IDisposable/ AddRef()/ Release())  
  
  
I see mildly typed object persistance combined with workflow frameworks taking us closer to this goal, in which light. the whole question of Microsoft.Data becomes moot :)
  
  
  
  
  
Si
  
  
  
  
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment63</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment63</guid><pubDate>Tue, 03 Aug 2010 19:40:33 GMT</pubDate></item><item><title>Paul Speranza commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>I think this is the new tool, called lighswitch
  
  
[www.zdnet.com/.../6981](http://www.zdnet.com/blog/microsoft/microsofts-lightswitch-building-business-apps-for-web-pcs-and-cloud/6981)  
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment62</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment62</guid><pubDate>Tue, 03 Aug 2010 17:06:18 GMT</pubDate></item><item><title>Ayende Rahien commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>Jonathan,
  
No, they don't. There are multiple ways to go around that.
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment61</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment61</guid><pubDate>Tue, 03 Aug 2010 16:32:53 GMT</pubDate></item><item><title>Frans Bouma commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>@Damien:
  
"The problem is that getting started with all that is too much of an initial concept count. Did you learn all that up front? Probably not. Like many good quality pro devs today you probably started with something simple doing console apps, maybe later with a GUI, then you learnt about DB's and SQL, web pages, security, MVC. Along the way you picked up OO, good design and maintainability.You can't *start* with all that, the learning curve is too great."
  
I started with Assembler and so on. The thing is that there's a contradiction: to be able to use Microsoft.Data, you already have to know a couple of things. When you know these, you already have invested a lot of time to learn them, and my question then is: why is it _accepted_ that these things are a prerequisite (as you can't create a webpage without it) but it's _not accepted_ when Linq to sql has to be used. 
  
  
Mind you, Razor might look simple but it too has quircks and edge cases and a learning curve, so does SQL. All that together is needed to be able to use Microsoft.Data. So you already have a certain level of dev experience. WHY is it then suddenly 'too much' to learn linq to sql?  
  
  
"I *believe* this is what WebMatrix is aiming at. Not at converting PHP devs but providing a simpler form of ASP.NET so people getting started have another choice."
  
What does 'getting started' mean here? A complete novice, new to programming, seeing a piece of code for the first time? No. A starter with ASP.NET? Perhaps, but then it is really really bad: bad practises. So IMHO a 'starter' means something in between, but then again the question pops up: linq to sql was too much, but all that other stuff wasn't. 
  
  
Or, was it because Linq to sql has to die and the only alternative was the EF which is  'too complex'?
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment60</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment60</guid><pubDate>Tue, 03 Aug 2010 16:32:50 GMT</pubDate></item><item><title>Karthik Hariharan commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>Despite many people's tendency to assume that WebMatrix was built because Microsoft thinks devs are dumb, I believe it actually has a noble cause in mind.
  
  
There are scores of developers that are flat out ignoring ASP.NET MVC due to perceived complexity, and a large part of the .NET community acting as naysayers and continuing to advocate WebForms because they believe it is an easier model that developers are already used to.
  
  
I think Microsoft is smart, and would love nothing more than to sunset WebForms and focus its efforts and resources into MVC so that they only have one solid Web Framework to maintain and enhance.
  
  
However, before they can even consider sunsetting WebForms, they have to nullify the MVC Naysayers and change the perception that MVC is too complex.  WebMatrix is their first attempt at doing so.
  
  
Those of us whose first instinct is to assume MS built WebMatrix for the advanced, MVC-supporting, developer would do well to keep all this in mind. We should quietly accept WebMatrix as a necessary evil to keep new development projects from choosing WebForms over MVC and nullify the complexity argument.
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment59</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment59</guid><pubDate>Tue, 03 Aug 2010 16:06:49 GMT</pubDate></item><item><title>Damien Guard commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>@Jonathan: They also help with culture-aware apps.  Sticking a string version of a datetime into a SQL string yourself can cause it to be misinterpreted entirely - e.g. a UK user of your web app uses your date-picker - you have the right DateTime object in memory but ToString formats it as 1/7/2010 instead of 7/1/2010 and SQL happily accepts it (this happens because web.config allows you to make the current thread culture align to their browser language-accepts).
  
  
This also affects numbers (some cultures use , as a decimal opint separator)
  
  
[)amien
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment58</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment58</guid><pubDate>Tue, 03 Aug 2010 15:50:08 GMT</pubDate></item><item><title>Jonathan Allen commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>@Troy Ok, wow. I didn't realize MySQL is screwed that up as well. Is there anything MySQL doesn't do wrong?
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment57</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment57</guid><pubDate>Tue, 03 Aug 2010 15:41:10 GMT</pubDate></item><item><title>Jonathan Allen commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>&gt; And escaping strings for SQL is a fast way to SQL Injection.
  
  
While I won't say parameters aren't nice, for a lightweight database like SQL CE all they do is save you the effort of writing `value.Replace(quote, quote+quote)`.
  
  
I honestly don't understand the utter terror of SQL Injection some of you have. Even when working with raw strings it isn't that hard to prevent it. 
  
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment56</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment56</guid><pubDate>Tue, 03 Aug 2010 15:35:13 GMT</pubDate></item><item><title>Damien Guard commented on Microsoft.Data, because the 90s were so good, we want to do them again</title><description>"ah, so they're downright incapable of using simple tools yet are capable of understanding how MVC works, how these render engines work and how databases work, what SQL is, etc. etc. ?"
  
  
The problem is that getting started with all that is too much of an initial concept count. Did you learn all that up front? Probably not. Like many good quality pro devs today you probably started with something simple doing console apps, maybe later with a GUI, then you learnt about DB's and SQL, web pages, security, MVC. Along the way you picked up OO, good design and maintainability.
  
  
You can't *start* with all that, the learning curve is too great.
  
  
PHP has a very low concept count which is one reason why it is enticing to new devs. They don't have to learn an ORM, OO, design patterns, MVC etc. They start with a HTML page and then drop some dynamic elements in using basic logic.
  
  
Sure they'll make mistakes but they start somewhere.
  
  
I *believe* this is what WebMatrix is aiming at. Not at converting PHP devs but providing a simpler form of ASP.NET so people getting started have another choice.
  
  
[)amien
</description><link>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment55</link><guid>http://ayende.com/4571/microsoft-data-because-the-90s-were-so-good-we-want-to-do-them-again#comment55</guid><pubDate>Tue, 03 Aug 2010 14:46:25 GMT</pubDate></item></channel></rss>