I just finished reading The simple twitter book by Brent Ozar (available free online).

EVERYTHING YOU NEED TO KNOW... told to you in a funny, friendly voice.

I thought it really accomplished its goal: being a simple and concise twitter beginner's guide. It’s very to-the-point, some of the tips are obvious but you didn’t really think about them until you read them, and it’s really funny.

It starts off with what everyone (familiar with the platform or not) would like to know: What is twitter for? Just seeing that was enough to get me hooked, and furthermore, seeing the first reason there was no turning back: Get better at what you love to do.

I bet right now there’s something you love doing - running, writing, building, whatever - and you wish you could do it better. Cyclists get motivated by seeing what’s going on in Lance Armstrong’s head. Writers would love to hear what Stephen King’s day is like. Programmers want to know about the latest techniques. Twitter helps us share this information easier and faster.

It then goes on explaining the basics: choosing a name, how to create a good profile page, how to get followers, who to follow, what to share, etc, all the way to more advanced stuff, like how to promote your business (successfully and without sucking) using twitter, passing through general tips and recommendations.

It was a a little satisfying to find that the top 10 reasons the author follows people (and the top 10 reasons he doesn’t) are pretty much the same ones I have; I unconsciously checked most of those things when evaluating a new account to follow.

These reasons are (for more detail, download and read the book!):

10. Your tweets show a sense of humor.
9. You have an awesome profile photo or name.
8. I know you in real life.
7. I’m friends with your spouse.
6. You tweet often and show pictures now and then.
5. You have a lot more followers than friends.
4. You’re interacting with other people I know.
3. You suddenly follow me on other social networking sites.
2. You’re using Twitter to announce your blog posts.
Reason #1: You’re doing cool stuff.

Among his recommendations, he says you should always try to reply at people that talk to you, it’s nice to see he follows his own advice (and fast too, look at the times!):

After finding the book I started following the author, at first I found he tweeted a bit too much, but I think he was just excited with a SQL Server release, we’ll see what the future holds for this unilateral relationship!

I strongly recommend you read this book, it’s very easy to read, clear, and with a lot of helper pictures to illustrate points, which makes it funny and relaxed.

Head over to Brent’s site and get it now! Limited offer!

http://www.brentozar.com/twitter/

Sure, there’s nothing officially wrong with trying to write multithreaded code in C++ on Windows using COM. But it’s prone to disastrous bugs, the kind of bugs that only happen under very specific timing scenarios, because our brains are not, honestly, good enough to write this kind of code. Mediocre programmers are, frankly, defensive about this, and they don’t want to admit that they’re not able to write this super-complicated code, so they let the bullies on their team plow away with some godforsaken template architecture in C++ because otherwise they’d have to admit that they just don’t feel smart enough to use what would otherwise be a perfectly good programming technique FOR SPOCK. Duct tape programmers don’t give a shit what you think about them. They stick to simple basic and easy to use tools and use the extra brainpower that these tools leave them to write more useful features for their customers.

From Joel Spolsky’s blog

According to this article, there is no question at all… the answer is not to delete. It could all also be summarize as “learn Domain Driven Design”, try not to always think technically and understand the business behind things.

As they say

I know it doesn’t show up as nicely on your resume as “3 years WXF”, but “saved the company $4 million in wasted inventory” does speak volumes.

Interesting read

I wanted to try out ASP.NET MVC in order to decide whether or not I could use it for a small project I’m starting, I’ve read nothing than good things about the Framework, but I hadn’t had the chance to try it on a real web site.

The first step though, is making it work. My hosting provider runs the windows server on IIS6, and does not allow custom configuration unless you buy a dedicated server, which I didn’t want to do, for now at least.

There are quite a few blog posts that explain how to run ASP.NET MVC on IIS6, but in all I read you need to have access to the web server configuration, to do one of two things:

• Setup a wildcard mapping
• Add an ISAPI mapping and have an extension (ie: .mvc) use the asp.net runtime.

This options were no good for me.

The solution was quite simple (well, it became simple after a little bit of research): Add a custom route, and map .aspx files to a controller.

You need to add this to the Global.asax file:

 routes.MapRoute("Main", "{controller}/{action}.aspx",

     new { controller = "Home", action = "Index" });

 routes.MapRoute("Default", "",

     new { controller = "Home", action = "Index" });

The only drawback is that you don’t get the “pretty” url you can get if you use IIS7 or have access to IIS6 configuration, but it works.

(Instead of having a url like this: http://yourserver/Home/Index, you get http://yourserver/Home/Index.aspx)

If the framework (MVC) is not installed on the server, you also need to copy the dlls to the bin directory, which they don’t get copied by default, you need to check the “Copy Local” property in the project references.

I've been reading The Pragmatic Programmer, which I bought some time ago, and today on the bus ride to work I read the concept of tracer bullets.

It's really nothing new, but I liked the analogy. When you fire a gun in the dark, sometime you need to use tracer bullets, which are special bullets that leave a phosphorus trail from the gun to where it hits. They are often used to avoid tedious calculations necessary if firing regular bullets in the dark. The feedback (where it hits) is immediate.

In the realm of programming, you'd use this concept for a step further in prototyping, you "prototype" the entire system, and the interactions between its parts, instead of each one individually. You build the skeleton of the application, which you can later fill with code.

This also gives you immediate feedback to see if each part will work and communicate correctly with each other, and it's specially useful for building stuff you have never built before.

I'm starting to like this book

One of the new features that came with Visual Studio .NET 2008 SP1, is the real-time compiler errors (feature I read VB developers have had for a long time).

So if you type something wrong, you see it without having to compile

I've been working with it for two days, and I definitely don't like it, it distracts me to have errors appearing and disappearing all the time, it doesn't even let you finish writing the line, it shows an error when there isn't one (I just need to finish the line please!). I found myself trying to type faster to avoid seeing the "error".

I'm sure they had good intentions.

Luckily, almost anything can be turned off, you just need to find it.

If you go to Tools > Options > Text Editor > C# > Advanced, and uncheck "Show live semantic errors", it works like before, only showing hints

I will go back to the old ways with this one...

As part of the development framework we are creating here in Iceberg I wanted to create a base web site that developers could use as a starting point, with themes, master pages, and some default properties set in the web.config file to use our database and membership engines.

My initial thought was to create it, and then have them copy/paste it to start a new web site, until I came across the "Export template..." feature in visual studio.

Basically what it does is package a project or item so it can be reused, exactly what I wanted.

Let's test it... first I create a project

And I added a few items, just to not let it the same as the default project

Then I go to File, Export template

You are presented with this self-explanatory dialog box

You click next, then finish, and that's it... you can add a new project and select this template as many times as you want (You can set a custom Icon and a Description if you want, play a little with this options if you like)

Today I was designing some unit tests for a project here at work, and needed to access some helper methods (mostly constants) to check the output of a few methods, and was happy to discover this attribute.

With InternalsVisibleTo you can specify which assembly, if any, other than the current one, can "see" information marked as internal.

As I said, it's very useful when designing tests, or for example if you want some component to be accessed only by another (the same use you give to internal, but expanding across several assemblies)

You can use it at assembly level like this

[assembly: InternalsVisibleTo("JMF.Tests")]

Where JMF.Tests is the Assembly Friendly Name

I found a nice and clear post about the c# yield keyword, I know a lot of you know about its existence, but a lot also don't as it's a little hidden from everyday programming practices.

It's here since .NET 2.0 (and I don't know if even before), and basically it's useful to return values you can iterate through, without the need to create a collection or array and returning it instead...

This is not really supported by the .NET runtime, it's a c# specific keyword, it gets translated to IL the same way it would if you return a collection and iterate through it

Check it out!

When you are working with control designers (or, for any reason) you sometimes have the need to debug class libraries in design time, and doing it is very easy.

To show you how easy it is, I created a sample solution consisting of a class library and a windows forms project.

The class library only has a custom Button, with only one property, like this

The Windows forms project contains a form, with my button

All you need to do is set the class library as the startup project, and set it to start with another instance of Visual Studio.NET.

Right click on the class library project à properties à debug à Start External Program

The default install directory for Visual Studio.NET 2008 is C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\devenv.exe

Press F5, and open your test solution when VS.NET loads.

And that's it! To test it, set a breakpoint in the property setter in the original instance of VS.NET and open the form containing the button from the second instance, it will stop when the designer tries to set the property

I originally did it with ASP.NET (I wanted to see how exceptions were handled in design time, to catch them, and show them formatted in red in the control designer of my controls), so it works perfectly with it too.