Shouldn't OLPC be renamed?

One Laptop Per Child is loosing its naming reason, as so many geeks are interested on it. It should probably be renamed to OLPG - One Laptop Per Geek.

Blog directory

Responding to Dare Obasanjo asks “what are those A-list technology bloggers good for?”, Scoble has just published his 35 top blog list. Here it is:

1. Mashable
2. Read/Write Web
3. TechCrunch
4. Media 2.0 Workgroup
5. digg
6. Sun bloggers
7. Gizmodo
8. ZDNet blogs
9. Planet Intertwingly (a bunch of bloggers show up here, including Dare).
10. All Facebook
11. MSDN Blogs
12. digg/Technology
13. The Unofficial Apple Weblog (TUAW)
14. RSS Feed for Lifehacker
15. GigaOM Network
16. VentureBeat
17. Chuqui 3.0
18. VentureBeat Wire
19. Y Combinator Startup News
20. Engadget
21. TechNet Blogs
22. Digital Backcountry - Ryan Stewart’s Flash Platform Blog
23. JD on EP
24. Google Operating System
25. A Welsh View
26. dzone.com: latest front page
27. All Things Digital
28. Dare Obasanjo aka Carnage4Life
29. Valleywag
30. Googlified
31. Ryan’s shared items in Google Reader
32. rexblog: Rex Hammock’s Weblog
33. Metaversed - Business and Technology News from the Metaverse
34. Business 2.0 Beta Blogs
35. CrunchGear

Some new goodies to add to my readings :)

WayPointer

Here is the way application should be build from now on: with guidance built in! Check WayPointer demo.

WayPointer provides an integrated solution for implementation of best practices for Requirements, Modeling, Documentation, Process, and Testing. WayPointer has unique active process support, that guides, reviews and automates the work that the users need to perform in a non-intrusive way.

NGP Deployed

Being a product of Jacobson's way of work, it's no wonder that I can relate to his principle's revocation (or should I say recant?). Here's the pragmatical NGP:

The Next Generation Process is a paradigm shift to make practices first class citizens. We no longer talk about entire processes, but the individual practices that make up a process. Practice definitions are defined separately and composed to form the process for the project team. Practice definitions can be transformed into formats that are readily consumed by vendor specific tools. Practices are submitted to an ecosystem from which development teams can consume them (using NGPI). Practices are automated, not only to provide contextual guidance to the development team, but at the same time reduce the effort required to undertake administrative tasks.

Use Annotations to Transform LINQ to XML Trees in an XSLT Style

A long time ago, I was on the first set of developers who believed that XSLT could be some general purpose Silver Bullet to solve many of our problems. After the first terrible experiences we all had, I've limited XSLT usage to some very well defined domains. One of this is XML transformation.

Here's an interest way to do it using LINQ.

Now that I think of it, isn't XSLT usage resurging from the ashes?

101 Ways To Know Your Software Project Is Doomed

Following Pedro's invitation, here is my list:

04. You have implemented your own Ruby framework that uses XML configuration files
09. You start considering a new job so you don’t have to maintain the application you are building
15. You are friends with the janitor
20. Your manager could be replaced by an email redirection batch file
23. Every bug is prioritized as Critical
28. You still believe compiling is a form of testing
72. he deadline has been renamed a ‘milestone’…just like the last ‘milestone’
74. Your boss argues “Why buy it when we can built it!”
79. Budget for testing exists as “if we have time”
80. The client will only talk about the requirements after they receive a fixed estimation
84. All performance issues are resolved by getting larger machines
85. The project has been demoted to being released as a permanent ‘Beta’ version (ok, this is not from my experience, but it's funny how gmail is still in beta...)
95. You have cut and pasted code from The Daily WTF
100. You have been 90% complete 90% of the time

Comprehensive comprehensions

Though functional programming purists may object, I find that the isolation of higher-order functions is useful, particularly if implemented as language extensions, not language rewrites.

That is the case of map, filter and reduce implementation as explained in diditwith.net. And where, groupby and select in LINQ.

Lambda the Ultimate is referencing a Microsoft Research proposal about comprehensive comprehensions. What's your side of the fence?

Visual Studio 2008 beta & TFS

My first experience with TFS just didn't work. In order to hookup with our TFS server, I've tried to install the Team Explorer 2005 - ok, I admit it, the fact that the 2005 setup was lying around and the 2008 was a download away may have anything to do with it.

I'm now downloading 2.7GB of TFS just to get the small footprint of Team Explorer. Oh, well, tomorrow is another day.

VisualWebGUI

I've been working on web application for years, but still miss the windows client way of life. Even today, with AJAX and tons of frameworks, the web experience just sucks for must of our user experience. But is still unbeatable on deployment and maintenance.

Here's an offer that can leverage both of this worlds: VisualWebGUI:

User-Friendly – Visual WebGui was designed to be the next VB6 for the web. Simple to program, simple to deploy. With a full WinForms API and design time support you can start developing complex AJAX applications in seconds with no web know-how.

Secured – Visual WebGui was designed to provide for military grade secured AJAX applications by eliminating client side service consumption and business logic processing using an empty client concept. The browser is used as a looking glass to the server that runs the application.

Productive – With full WinForms API and design time support, Visual WebGui is almost as productive as R.A.D. platforms without limiting your options. Debug your application the same way you would debug any .NET application free of script debugging nightmares.

Powerful – Visual WebGui was designed to support enterprise class applications with unlimited complexity supported by full object oriented programming. Using our unique AJAX transport, Visual WebGui applications consume 1% of bandwidth compared to any alternative AJAX framework.

Feature-Rich – Visual WebGui contains most of WinForm's components including non trivial implementations of controls such as the PropertyGrid that provides a simple way to edit live objects.

Supported - Visual WebGui is supported by its Core Team of developers and a dedicated international community. Through online forums and our support@visualwebgui.com mail box support is always close at hand (commercial support will be available soon).

Easily Installed – Visual WebGui comes with a simple installation that will get you started on developing your AJAX application in no time. Visual WebGui's toolbox and templates are integrated into Visual Studio so they are always available.

Localized – Visual WebGui includes full .NET and WinForms multi-language localization support which allows you to localize your application in the designer the same way you localize a WinForms application.

Open Source – Visual WebGui SDK is provided free, as open-source software, and licensed under a standard LGPL agreement. It allows individuals to do whatever they wish with the application framework, both commercially and non-commercially.

Cutting-Edge – Visual WebGui provides the developer with full object oriented .NET support allowing utilization of all the .NET capabilities including reflection, generics and more. This is enabled by a unique architecture that provides an alternative HTTP processing pipeline that does not include serializing JavaScript.

Extensible – Visual WebGui is provided with many customization and extensibility features including custom control creation, theme creation and gateways.

Interopable – As an extension to ASP.NET, Visual WebGui can also interact with standard ASP.NET pages hosting them within your Visual WebGui application or calling Visual WebGui dialogs and forms from your ASP.NET code.

Visual WebGui's roadmap includes…

Mono deployment - Allowing your Visual WebGui application to run on non Microsoft servers (Visual WebGui for .NET 1.1 is already compatible with mono).

Legacy to web – Migrating WinForms or VB6 applications to web with out rewriting your application.

Dual mode deployment – Deploy your Visual WebGui application as a desktop application or a web application enjoying the best of both worlds.

referenced in: ISerializable

Visual Studio 2008 beta 2 versioning

After installing the beta 2, my projects just stopped running... It seems like the version is finally 3.5, not the 2.0 of the beta1. So you'll have to replace Version=2.0.0.0 to Version=3.5.0.0 on your config files, like:

<add assembly="System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=B77A5C561934E089">

[update] you can always use the studio form (solution > properties > references)

Yeap, yet another version messup from Microsoft. And I can understand it, being 3.0 a 2.0 plus a 4 library set, the 2.0 was maintained on the core. With 3.5 the core itself was kept pretty much the same from 2.0, but still had it changes, so the 3.5 was in order.

The good news is that other than that the projects I've tried as still running. Let's wait for the first news from the performance gurus :)

VS 2008 and .NET 3.5 Beta 2 Released

As announced, here is Orcas beta 2. I've just started the download, so all I can say for now is that we should be receiving a cleaner build - from over 5GB on beta1 to 3.1GB. And please watch out for the installation notes.

More about this version as soon as I can put my hands on it - unfortunately I'm overwhelmed with meetings tomorrow.

Partitioned-Iterative more appropriate for EA than Zachman, TOGAF?

I'm totally of my natural environment here - only posting about this because this kind of approaches are in my wish-list, and probably because the company I work on has a division that follows one of this EA methodologies.

Here's what InfoQ as to say about it:

The advantages of Partitioned Iterative Approach, according to Sessions are:

• Faster Time To Value (TTV). Sessions means that this is a more important success factor in the business world than measuring Return On Investment (ROI). A vertical slice can be delivering perceived value long before completion of the rest of the project, even before it has a positive ROI. "If you can show, for example, that within the first month, the library has already decreased the length of customer calls to the help desk by 20%, you are showing value, even though you may be years from showing a positive ROI for the overall project.
• Increases the overall chances of a successful project, due to the possibility to apply the lessons learned in earlier iteration.

Sessions concluded his partitioned approach proposal by giving three rules for success for an enterprise architecture, summarized here:

1. Start with low-hanging fruit. The important thing in developing an enterprise architecture is to demonstrate success. This will help build momentum for the larger goal.
2. Leverage economy of small scale. Use a relative small group attacking a well-defined partition of the enterprise.
3. Centralize interoperability, decentralize implementations. A centralized enterprise architectural organization is necessary. But the central organization needs to focus on the right issues, and not get bogged down on issues that are irrelevant. The general rule of thumb is that decision that impact interoperability should be centralized. Decisions that impact implementations should be decentralized.

Gatineau: Microsoft's anti goolge analytics

Gatineau, Microsoft's web analytics tool, looks like it is getting close to seeing the light of day. Apparently after an adChamps briefing in London, an attendee, Dave Naylor, got hold of some Gatineau screenshots and posted them. Then Ian Thomas, who is "responsible for bringing Microsoft's new web analytics solution, codenamed Gatineau, to market", rather than scurry about trying to get the screenshots taken down, did the right thing and just posted some good information about Gatineau, how to sign up for the alpha testing, and promising more soon.

taken from: bink.nu

Software Process Methodology back in 1998

Back in 1998, the company I was working in (SMD Informática) made this short movie documenting the cycle of software projects. This movie was presented on our yearly customer's meeting, and needless to say, it was a success.

Google Base vs. Microsoft's Astoria

Here's a great comparison from Dare Obasanjo. He ends with the following conclusion:

In comparing both approaches there is a lot to like and dislike. I like the "expand" feature in Astoria as well as the fact that I can retrieve XML results from multiple paths of the hierarchy. However there does seem to be a paucity of operators and functions for better filtering of results.

From the Google Base data API, I love the "crowd" feature and having a full library of functions for performing tests within predicates. Also some of the operators such as the ones for finding results near a certain location are quite impressive although unnecessary for the majority of RESTful protocols out there. That said, I do think they went overboard on some of the features such as having if...else blocks within the URIs. I suspect that some of that complexity wouldn't have been needed if they just had hierarchies instead of a flat namespace that requires complex filtering to get anything out of it.

What's the Web’s Weakest Link?

According to GigaOM, is the Power Grid. And he may be right. Are we really "building a Taj Mahal on quick sand"?

Hotfixes are finally self-served

You can now simply go to this URL and download most any fix

https://support.microsoft.com/contactus2/emailcontact.aspx?scid=sw;en;1410&WS=hotfix

You will get a form mail in response, and in it will be a link to the http site you can download the fix from.

in: bink.nu

Code reuse highly overrated?

Dennis Forbes questions the tendency of many in-house dev teams to spend a lot of time building in-house frameworks and libraries intended for reuse across projects:

The greater the bulk of code you accumulate, the more intrinsically you tie yourself to your current developers (and the more they occupy their brain with information that is only applicable in one organization or team), and the more difficult it will be to bring new developers online. Such frameworks and libraries often come with enormous learning curves for new hires - especially as documentation is virtually always ignored - and they can seldom be reused for anything else without significant refactoring (because they likely weren't truly designed for reuse, or they were in only the most arbitrary and superficial of ways…

… The question every organization needs to ask itself, then, is what value they could sell their "reusable code" for - what, realistically, would competitors and new entrants in the field offer for it? The answer, in almost every case, is $0, and they wouldn't want it even at that price. There is extraordinarily little code theft in this industry (even though we're in the era of burnable DVDs and USB keys) because most code - above and beyond the industry-wide frameworks and libraries - has no value at all outside of a specific project with a specific group of developers. Trying to use it for other projects is often worse than starting with nothing at all.

InfoQ states:

Forbes concludes that because properly abstracted and generalized frameworks are more expensive to design and develop than one-off solutions, and since the time and cost for a developer to absorb the complexity of a new framework is rarely taken into account when doing a code reuse cost benefit analysis, it makes sense to reuse code a lot less often than one would think.

Though agreeing when talking about general frameworks (and yes, this is still code reuse, it is just not developed and maintained by our organization), there is still space for code reuse over domains that differentiates our organization from the competition. These should be the domains where we should put our efforts, bearing in mind that we should decouple this code the most we can.

And watch out, lets not fall all over again on the NIH syndrome. And above all, please reuse the same frameworks all over your organization! The frameworks don't need to be built in house, but they should be coherent and cohesive. Please don't build your projects over too large palette of frameworks.

Vista use grows as Mac OS X stays flat

If you've just return to earth after a long voyage across other galaxies you would be asking yourself something like: "the latest Microsoft OS is recovering from the latest Apple OS?". Otherwise the recovering trend is in fact the surprise, after some very aggressive moves from Apple and warm Vista reviews. It seems that at last the "pre-installed Microsoft OS"
pattern is collecting their dues...

Powered by all of us

I just love Wikipedia, and the wiki concept in general. Here's a great link about errors in the Encyclopædia Britannica that have been corrected in Wikipedia.

taken from: slashdot

When asserting too much...

A friend of mine as just told me a funny bug. His client had just messed up some certificates so his application stopped working. Nothing new here, the client just reissued the certificates, but the application could only be started after 3 service restarts!

After reading some logs the problem was identified: the application protocol started by retrieving the first entries from the event viewer. So it was clear that the event viewer collector was poorly written, just putting the event viewer content directly on the web service response, thus generating badly-formed XML depending on the content. After the restarts, the restart information replaced the well-formed XML offender, solving the problem :)

And here's yet another scenario where logging too much information can put you in trouble :)

Hanselman's on his way to Microsoft

Hanselman's on his way to Microsoft, heading for ScottGu's dream team. Good for you, Microsoft. Hope Hanselminutes will remain on track.

Merge in SQL Server 2008

At last, a new feature on a database!

merge [target] t
using [source] s on t.id = s.id
when matched then update t.name = s.name, t.age = s.age -- use "rowset1"
when not matched then insert values(id,name,age) -- use "rowset2"
when source not matched then delete; -- use "rowset3"

Read it about it here.

FamilyShow 2.0

Family.Show is a genealogy program that demonstrates the usage of WPF for a complex, realistic scenario. If you're a fledgling WPF developer who wants to pore over some code that demonstrates best practices for application construction, there's nothing better out there today.

I believe this was done by the same company/team that built IBuySpy and IBuyPortal demos.

Creating online communities

Here's how to. You can always start by this great Google Analytics How-To.

Powered by Osherove, the agile evangelist that plays guitar on technical conferences.

NHibernate parent/child relationship

One of my favorite features in an ORM is the ability to represent associations as first class elements. But my parent/child implementations observed this weird behavior: after adding the child, NHibernate didn't issue one SQL INSERT command, but an INSERT that didn't set the foreign key, followed by an UPDATE that did set it.

After some googling I found the answer here: the underlying cause of this behaviour is that the link (the foreign key) from parent to child is not considered part of the state of the child object and is therefore not created in the INSERT. So the solution is to make the link part of the child mapping, something like this:

<many-to-one name="parent" column="parent_id" null="true">
</many-to-one>

Now that the child entity is managing the state of the link, we tell the collection not to update the link. We use the inverse attribute:

<set name="children" inverse="true">
  <key column="parent_id">
    <one-to-many class="Child">
    </one-to-many>
  </key>
</set>

For much as I hate the RubyOnRails platform...

Yes, it's true, every now and them I miss some of the RubyOnRails concise form. And this Friday was one of them.

We were refactoring some of the ternary associations on NHibernate to get a cleaner implementation - we were using it as a simple entity class, as describer here (6.3.4). In order to try some alternative implementation, we had to refactor the HBM, the domain model and the unit tests. The crazy thing about this refactoring is that most of the domain model could be inferred from the HBM. And yes, I'll have to admit, this is where RubyOnRails kicks C# and java asses...

How to Spot a Failing Project

One more study, the same old facts:

"As of 2006, the absolute failure rate is down to 19 percent," Johnson says. "The success rate is up to 35 percent." The remaining 46 percent are what the Standish Group calls "challenged": projects that didn't meet the criteria for total success but delivered a useful product.

Here's something good (for people like me who work on small projects):

What is perhaps more troubling is that the bigger the project, the worse the problems. "Seventy-three percent of projects with labor cost of less than $750,000 succeed," Jim Johnson says. "But only 3 percent of projects a with labor cost of over $10 million succeed. I would venture to say the 3 percent that succeed succeeded because they overestimated their budget, not because they were managed properly."

And here's something troubling for people who believe agility is the answer for all problems:

(Perhaps significantly, agile project management is notoriously least effective on very large projects.)

Makes sense. From now on I'll target on small projects where agility can work :)

Finally, the hints:

• Lots of overtime
• Diversion of resources
• Ratios trouble
• Milestones aren't met

Microsoft PlayAnywhere. The version for the poor of the costy Surface

At this week’s Faculty Research Summit, Microsoft researchers showed off, yet again, PlayAnywhere.

taken from: bink.nu

Mini-Guide: Hibernate and NHibernate

Mini-Guide: Hibernate and NHibernate

Be a Better Developer in Six Months

Here's another great podcast from Hanselman: Be a Better Developer in Six Months.

As always, he chooses practice over theory. Yes, I agree, reading the opened source CastleProject and Enterprise Library is a great way to become a better developer :)

How much money do you make for your company?

He, eh, eh, do you make this kind of money for your company?

Company	Full-Time Employees (globally)	Net income	Added Value / Employee
Wal-Mart	1,900,000	M$ 11,284.00	$ 5,938.95
Costco	71,000	M$ 1,103.00	$ 15,538.24
Microsoft	71,000	M$ 12,599.00	$ 177,450.70
Oracle	74,674	M$ 4,274.00	$ 57,235.45

Source of data: moneycentral.msn.com

taken from here.

Bumpler & Mean Fiddler: isn't it fun when...

Isn't it fun what some neat coding over already proven frameworks can easily do?

Here's Jasper: Bumbler: NHibernate Dynamic / Interactive Shell

And here's Astoria: Mean Fiddler: REST-style query service


Great posts you guys!

LINQ to SQL - Part 5

Here's another link from Guthrie's series about Link to SQL.

The way Scott cleans up the columns is the way ORMs usually deal with this columns, not the traditional SQL-centric leftouterjoin way.

Some of the some C#2, C#3, LINQ, Ruby, Python and Haskell code

Diditwithdotnet post this great article about a higher order calling. Here's the compilation of the final code (without the generic implementations) from the article comments.

C#2

static void Main()
{
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
IEnumerable<int> evens = Filter(numbers, IsEven);
IEnumerable<int> squares = Map<int, int>(evens, Square);
int sum = Reduce(squares, 0, Add);

Console.WriteLine("Sum: {0}", sum);
}

C#3

static void Main()
{
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };

int sum = numbers.Filter(x => (x % 2) == 0).Map(x => x * x).Reduce(0, (x, y) => x + y);

Console.WriteLine("Sum: {0}", sum);
}

LINQ

static void Main()
{
var numbers = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };

var sum = (from n in numbers
where (n % 2) == 0
select n * n).Sum();

Console.WriteLine("Sum: {0}", sum);
}

Python

sum([x*x for x in range(1,16) if x%2==0])

Ruby

(1..15).select { |x| x % 2 == 0 }.map { |x| x ** 2 }.inject { |x,y| x + y }

Haskell

sum (map (^2) (filter (\x -> x `mod` 2 == 0) [1..15]))

This post will not end with a conclusion nor a preference, because we are talking about a choice of flavor. In respect to this sample, all languages have the capability to solve it.

Microsoft LicenseWise

Microsoft LicenseWise for Volume Licensing is a “one-stop shop” that can help you recommend product and licensing solutions to your customers, optimize your sales process, and build new revenue opportunities.

Some of my Ruby on Rails fears...

Marc Palmer as just posted a great article regarding grails, where some of my fears are referenced:


interpreted v.s. compiled (ok, bytecode, the native code is out of this discussion):

Groovy compiles to Java VM bytecode at runtime. It is never, ever, ever interpreted. Period. Never. Did I say never ever? Really.

direct database reference v.s. domain model:

There is also no such thing as a domain model in Rails. Rails models are database tables. This is all well and good, but in enterprises the same domain model is often re-used in multiple applications both desktop and web.

Using memcached with ASP.NET

Here's what could be a future trend: using memcached distributed cache instead of ASP.Net's built-in caching.

FileSystemWatcher

Here's a great little sample of FileSystemWatcher from Roy Osherove. Tank God for anonymous delegates :)

FileSystemWatcher watcher = new FileSystemWatcher("c:\\");

watcher.IncludeSubdirectories = true;
watcher.Changed+=delegate(object sender, FileSystemEventArgs e)
{
 string file = Path.GetFileName(e.FullPath);
 string dir = Path.GetDirectoryName(e.FullPath);

 ...
}
                                };
watcher.EnableRaisingEvents = true;
        

Internal DSL in C#!

Fowler as posted some interesting links from Anders Norås on writing internal DSLs in C#. The first article gives a sample of the DSL and a discussion against Chromatic's cynical check-list. The second article goes into details about its implementation.

in: martinfowler.com

mendum: a new blog is born

My colleague and good friend Pedro Oliveira as just created his new technical blog. Please register this link, as Pedro is as nerd as you can get.

Great name, mendum! Keep it posting, Pedro!

Announcing Oracle Database 11g

Here it is, not much to invent in the database arena, the list of new things is as dull as the list from SQL Server 2008.

LINQ to SQL - Part 4

Here's another link from Guthrie's series about Link to SQL.

Apart from the usual demo, I particularly liked:

• Custom Entity Insert/Update/Delete Method Validation (add validation logic that is specific to insert, update or delete scenarios)
• Custom Property Validation Support (OnPropertyChanged)
• Custom Entity Object Validation Support (OnValidate)

To some extent, seems like some of Lhotka's CSLA.NET concepts are represented here.

NHibernate: LazyInitializationException

A common issue in a typical web application is the rendering of the view after the main logic of the action has been completed, and therefore, the NHibernate Session has already been closed and the database transaction has ended. If you access detached objects that have been loaded in the Session inside your ASPX, you might hit an unloaded collection or a proxy that isn't initialized - this is a common problem with datagrid databinding. The exception you get is: LazyInitializationException: Session has been closed (or a very similar message). Of course, this is to be expected, after all you already ended your unit of work.

The solution often presented is to set an HTTP interceptor to ensure session lifetime (namely: nhibernate.org, where most of this post was taken from). On my first NHibernate project, I've decided to wrap it up on my DataPage, a session aware class deriving from System.UI.Web.Page. With this simple solution I can easily differentiate session aware pages.

Launch Date set for Visual Studio 2008, SQL Server 2008 and Windows Server 2008

Yesterday in Denver at Microsoft's Worldwide Partner Conference Kevin Turner announced Windows Server^® 2008, Visual Studio^® 2008 and Microsoft SQL Server™ 2008 will launch together in Los Angeles on Feb. 27, 2008:

And your question to me might be when, when will you do this Microsoft? It says announcing; when?

Well, here's when. We're going to do it on February 27, 2008 worldwide. It's the biggest single launch we've got in Microsoft on one day.

Microsoft also stated that the Beta 2 of Visual Studio is on track to release later this summer with a release to manufacturing for both Visual Studio and Windows Server by the end of the year.

in infoq.

Free web templates

Here's a great opensourcetemplates.org.

Lambda rules

Here's a cool piece of code, taken from the vbteam:

MsgBox((From c In _

CheckedListBox1.CheckedItems).Aggregate( _

Function(ByVal x, ByVal y) x + "," + y))

Ok, the post issues some performance considerations (mainly because we are not using StringBuilder), as well as some reuse considerations, but the code itself is clear and simple. And yes, I finally posted some VB.NET code :)

Yet another LINQ to SQL demo

Here's the last series of LINQ to SQL from Scott Guthrie:

Part 1: Introduction to LINQ to SQL

Part 2: Defining our Data Model Classes

Part 3 - Querying the Database

What's new about this posts? Nothing really, except for the clear vision Scott as accustomed us in his demos.

In the defense of the blogosphere - III

Here's another reason to keep on blogging: worldwide audience! This is the ClustrMap of my insignificantly and unfocused blog 24 days after I finally ClustrMapped it.

The results may not be as impressive to other blogs, but are impressive to me. Being able to talk to people all over the world is something that only a few powerful and influent people could do until now.

But there's something about this map that is still a shame for the human kind: the map distribution is not consistent with people distribution. Let global audience and freedom of speech be the seed to end with it. Blog for it!

Words to live by

Great coding best practice taken from here:

Always code as if the person who will maintain you code is a maniac serial killer that knows where you live.

REST vs SOAP

Sometimes I find some (very!) distracted people on our business that haven't heard about the REST vs SOAP wars. Here a great little article explaining the basic differences.

PS: ok, so REST is wining.... go, SOAP!

Butler Group names OutSystems a Leading Rich Web Applications' Solution

The Butler Group, a Datamonitor Company, recently published a Report on "Rich Web Applications" that identifies the top ten players in this landscape, recognizing OutSystems as one of the worldwide leaders and the only one that showed no technological weaknesses. Furthermore, the Butler Group distinguished OutSystems as a vendor to consider in every technology selection process. OutSystems Solution is considered by Butler Group as being an end-to-end management and development environment that guarantees applications' full lifecycle management.

Moreover, Butler Group states that OutSystems Solution brings "the benefits of rapid development combined with automation, lifecycle management, and yielding high-quality applications".

If you would like to learn more about why Butler Group considers OutSystems as one of the top-ten leaders in Rich Web Applications, check it out here.

In the defense of the blogosphere - take II

Here's another great reason for posting your blog: I find my blog as a great search portal for my domains of interest. Sometimes Google is just too wide. And what better domain of interest then the blog I posted my interests on? Ok, it will only work for me, naturally...


This concept can also work on a community level. I have a blogroll of people who's opinions I respect, and it is often from that blog community that some of the my view of this world is built upon. In that respect, FeedDemon is just an awesome tool. And so is google custom search and one of it's best implementation: searchdotnet.com.

Windows losing ground with developers

in: Inside Windows Embebed.

A yearly study done by Evans Data, reported by InfoWorld (and being discussed on Slashdot), shows developers targeting Windows platforms fell to 64.8% this year, from 74% in 2006. Developers targeting Linux rose from 8.8% to 11.8% a year ago - seems small until you realize that's a 34% increase, and Windows dropped 12%.

This is good news folks! There's nothing like great competition to make Microsoft give us better developing products.

Storming Castle Windsor & NHibernate - Code & Presentation

Here's a great demo from Ayende.

GAX 1.3 - support for Orcas & more

in: msdn/agile

GAX 1.3 is here, and is supporting Orcas.

• New GAX installer (using Wix)
• Experimental hive support
• VB templates support in GAT generated packages

Introduction to .NET 3.0 for Architects

Here's a great introduction to .NET 3.0 for Architects. The version messup is very well explained.

And now for something completely different

Here's the geekiest joke of the day:

2 programmers talking:

• Hey, look at that girl!
• Not my type.
• Just cast it, man!

Entity Framework - "June" CTP

in: dsimmons

Here's a partial list of the features (largely plagarized from the ADO.Net team blog post on the topic)

• IPOCO -- there's a lot more coming here to bring us closer to true POCO, but this is the first step in that direction and makes the key change to allow the creation of Entity classes that do not inherit from our base class.
  
• ObjectContext.Detach() -- will detach an object from the ObjectStateManager associated with an object context so that it can be attached to some other context or reclaimed by the garbage collector
  
• Multiple entity sets per type -- this is relatively esoteric, but it does exactly what its name says. You can define a model which has more than one entity set with the same base type. This is important because it enables models which work more naturally with various database models. If you have two tables with the same schema (say "accounts" and "expired_accounts" or something), then you can define entitysets for each of them which use the same entity type rather than needing to create a different entity type which just happens to have all the same properties. This resulted in a change to a number of the object context APIs -- strongly typed contexts, for instance, now have AddToEntitySetName methods (where EntitySetName is the actual name of each entity set).
  
• Support for referential integrity constraints -- This allows you to define a key to one entity type which is made up, in part, of properties which are also in the key of another entity type. The modeling scenario in the database is where a column is both a foreign key and part of a primary key.
  
• Span -- this makes it possible to specify that a query not only return an entity but return some set of related entities in a single round trip and automatically hook-up the graph. So, for instance, you could say that your customer query should also return the orders for each customer in a single round trip. We also have an automatic query re-write feature for the object layer that enables a feature we call Relationship Span where queries that retrieve entities will under-the-covers also return relationship information if the relationship is an EntityReference (rather than a collection). This is usually a quick operation since typically this relationship information is co-located in the relational database as a foreign key property, and it has the very useful property that for many cases entity graphs will automatically be hooked up as long as the relevant entities on either side of the relationship have been loaded. So, for example, if I query for a set of customers and then I separately do a query for a bunch of orders--any of those orders that are related to those customers will automatically bring along the relationship info and connect the orders up to the customers they go with.
  
• Transactions -- specifically integration with System.Transactions.
  
• Serialization -- that is, entities are automatically generated with attributes that enable binary serialization. Unfortunately EntityKeys do not yet serialize but that will be coming in a future CTP.
  
• No more default constructors in code-generated classes -- I've already written about this in an earlier blog post.
  
• Improvements to stored procedure support -- honestly I can't remember the details of this one just now, and since I'm sitting in the Denver airport where I have limited battery life on my laptop I'll delay looking it up for you. If anyone is wondering, drop me a note and I'll get back to you.
  
• Access to the underlying store connection -- You can now easily access the store connection from an EntityConnection which makes it much easier to go around the covers if you need to. (But I must say I don't have to do that nearly so often now as I used to -- this framework is actually starting to work pretty well for writing apps, IMHO .)
  
• Directory macros -- Makes it easier to specify where the metadata lives in hosted scenarios
  
• Native SQL read-only views -- You've got to see one of the demos Tim Mallalieu runs where he shows the entity framework accessing sharepoint or some other schema that otherwise really doesn't fit the model.
  
• UNICODE support in Entity SQL
  
• Query plan caching and I'm pretty sure we do some metadata caching across app domains as well, but that may not be fully online yet in this CTP release.
  
• Canonical functions in Entity SQL
  
• Associations between sub-types -- This one is a biggy (as if the others aren't). Before this change, the entity types that are on the ends of relationships had to be the base type of an entityset, but after this change you can define relationships between any types in the type hierarchy even if they aren't the base types. So, for instance, if I have a hierarchy that has Customer and BigAccountCustomer, then I could create an entity type DiscountPolicy and a relationship that only relates BigAccountCustomers to DiscountPolicies not just regular customers.

Automaton

Automaton is a Continuous Integration engine for Microsoft Team Foundation Server. Automaton will monitor your source code repository and automatically run the correct team builds that you create within Visual Studio. Build reports can be view through a web site, and your development team can get notifications on e-mail or MSN Messenger when there is problem building the source code.

SQL Server 2005 Best Practices Analyzer (July 2007)

The SQL Server 2005 Best Practices Analyzer (BPA) gathers data from Microsoft Windows and SQL Server configuration settings. BPA uses a predefined list of SQL Server 2005 recommendations and best practices to determine if there are potential issues in the database environment.

7 Approaches for AOP in .Net

Great comparison. Read it here.

MSF Agile Frame (Workstreams and Key Activities)

Workstreams are simply groups of activities that flow logically together and are usually associated with a particular role. Meier couldn't find this view in MSF Agile, so he created it here.