Tek Corner

Careful with Abstractions

2012-02-03T12:31:00.001-02:00

Browsing around MSDN the other day, I bump into the following paragraph:

"The order and types of binding elements in Bindings are significant: The collection of binding elements is used to build a communications stack ordered according to the order of binding elements in the binding elements collection. The last binding element to be added to the collection corresponds to the bottom component of the communications stack, while the first one corresponds to the top component. Incoming messages flow through the stack from the bottom upwards, while outgoing messages flow from the top downwards. Therefore the order of binding elements in the collection directly affects the order in which communications stack components process messages. Note that WCF provides a set of pre-defined bindings that can be used in the majority of scenarios instead of defining custom bindings."

Most programmers understand the concept of a stack. It's a abstraction for a data structure which allows new data items to be removed in the exact opposite order which they were inserted, that is, the first element to be inserted is the last to be removed (FILO).

And most people knows what a stack is: a pile of stuff.

And the deal with it is that you can only add /remove stuff to/from the top. The text on MSDN, however, goes through great length to tells us to imagine a stack that adds to the bottom, and that the message goes from bottom to top. A upside-down stack, in other words. Whoever wrote that was so deep into abstracting his communication stack is a certain way that he forces us to think in a counter-intuitive way. It would be easier for the author to change the way he thought about it.

I used to say that some people, sometimes, are so fixed onto a solution that when the solution doesn't works, they adapt the problem.

Whenever you are writing a technical article like this, be careful with your abstractions; They should help people understand the problem better, so if you have to explain your abstraction (instead of explaining how it relates to the concrete problem itself), something is wrong. Like code smells, if you see a upside-down stack or any other abnormality appearing in one of your texts, take the time to review it.

A Postfix Calculator, Step-by-step - Part 1

2011-12-17T20:12:00.001-02:00

Goal

Recently, I was introducing the C# language to someone from work. I gave him a few challenges, but after a while a colleague of mine asked him if he would be able to make a postfix calculator, or a calculator which uses postfix notation. More than that, we wanted to design a postfix expression evaluator (instead of a common calculator which receives a single operation as input).

The objective of this series of posts will be to show a step-by-step analysis of the problem, the design, implementation and, finally, testing. It seems an ideal for first-timers, being simple to implement but requiring a more deep analysis and thinking.

Analysis

The cool thing about this exercise is that, once understood, it's very simple to implement, while at first it may seem very complex. Most of us (myself included) knows this type of calculator as an user: you first enter operands and then the operation. But the inner workings are deceiving: they look convoluted and counter-intuitive.

Again, we are deceived by our mind... this kind of calculator is much more simpler than an usual expression evaluator. Let's begin by analyzing an example... let's see an addition in postfix:

Table 1 - The Polish Reverse Notation

Common Notation	Postfix Notation (PRN)
10 + 5	10 5 +

Looking at the example, you can see that you should change the reading order of the expression in order to understand it more easily. Our brain (probably, since I'm no psychiatrist here) usually reads the first expression as:

1. Read 10, hold the value.
2. The operation is "add", seek another value.
3. Feeds 5 into the "add" operation.
4. Returns 15.

Listing 1 - Evaluating an Expression

Or something like that. In the Occident people learn to read left-to-right, and it's expected that we apply the same rule to expression reading. Take a look at the steps above. Are they simple? Not really. To execute the second step, you must execute another! It seems that our brain in making a call to a subroutine.

Now, let's look at the second expression. How to read it? We could apply the same left-to-right reading rule. We would have to store the values in two areas first and later retrieve then in order to perform the addition. Insightful readers may already have realized that it's easier to reading the expression right-to-left:

1. The operation is add, seek two values.
2. Feeds 5 into the add operation.
3. Feeds 10 into the operation.
4. Returns 15.

Listing 2 - Postfix Evalutaion

Hmm, what changed? It's simple enough, you see. You first understand the operation, which leads you to seek enough operands to perform it. But wait! There's another notation that looks exactly like this, isn't it? Take a look below:

Table 2 - Enter C-Like Notation

Common Notation	Postfix Notation (PRN)	C-like Notation
10 + 5	10 5 +	add(5, 10)

Wow! It looks like a common function (method) call, doesn't it? This is an advantage of postfix; All in all, it looks more like how a machine would work than the "common notation". Now, another advantage of the PRN is that it doesn't requires parenthesis. Let's see another example:

Table 3 - Parenthesis in PRN

Common Notation	Postfix Notation (PRN)	C-like Notation
10 + 5	10 5 +	add(5, 10)
(10 + 5) * (10 + 2)	10 5 + 10 2 + *	???

It's becoming harder. I have involved another operation (multiplication) to exemplify the parenthesis. But now, how does one evaluates the PRN above? Again, I will risk trying to explain the brain process behind it:

1. The operation is multiplication, seek two values.
2. Ooops! Operation!?
3. ...

Listing 3 - How to multiply?

Things get complicated after you read the value to the multiplication. As it turns out, it's not a value, but another operation. What if we evaluate it and feed the result into the multiplication?

1. The operation is multiplication, seek two values.
2.1. The operation is add, seek two values.
2.2. Feeds 2 into the add operation.
2.3. Feeds 10 into the operation.
2.4. Returns 12.
3.1. The operation is add, seek two values.
3.2. Feeds 5 into the add operation.
3.3. Feeds 10 into the operation.
3.4. Returns 15.
4. Returns 180.

Listing 4 - Multiplication Complete

OK, it's working properly. The call to multiplication resulted in two other calls, both to, again, adds. It seems that whenever we are evaluating an operation, we might run into another one. Hmm... which may lead into yet another one and so forth. This looks a hell lot like recursion, doesn't it? Well, hold that thought for a moment; we still must fill the third column of the table.

How would the operation above looks like in "C-like notation"? Let's again assume a multiply operation, just like add.

Table 4 - C-Like for Multiplication

Common Notation	Postfix Notation (PRN)	C-like Notation
10 + 5	10 5 +	add(5, 10)
(10 + 5) * (10 + 2)	10 5 + 10 2 + *	multiply(add(2, 10), add(10, 5))

Looking good! We have already established the principles and already projected the calculations to a computer language.

So let's focus on the C-like notation and expand it, after all, we are building a program, aren't we? Let's take another look at the steps in listing 4. There is something that calls attention: "seek two values". We do that a lot, don't we? Let's us assume that we could have an operation that seeks those values and then evaluate it. Could that be possible? Enter X(), a function that does that for us.

So

multiply(add(2, 10), add(10, 5))

becomes

multiply(add(X(), X()), add(X(), X()))

What's this X operation we are talking about? An operation that extracts something from the expression and returns its value. And doesn't both multiply and add do exactly that -- return a value from an expression? Oh yes, they do, and they are recursive, because, before returning a value, they will extract two more values from the expression. Yes! We got back to that recursive thing, didn't we? I told you to hold on to that, didn't I?

(I said that this was a good exercise for first timers, but recursion is an advanced topic. If you need help to follow it, go to Wikipedia.)

Anyway, if X takes something out of the expression (an operation or operand) and chooses whether to call multiply or add? Then, add and multiply can rely on X to retrieve more data. We have a two-step recursion (A calls B, B calls A). Let's check an algorithm that uses this X thing:

Let X:
1. a ← next_factor
2. If a is a multiplication
2.1 b ← X() (recursion)
2.2 c ← X() (recursion)
2.3. Return b times c
3. If a is an addition
3.1 b ← X() (recursion)
3.2 c ← X() (recursion)
3.3. Return b plus c
4. a must be a value, so, return a (else)

Listing 5 - Recursion

So far I have avoided the non-commutative operation subtraction and division. That's because there's a particularity in PRN, which is that the operands to an operation are always read left-to-right. In addition and multiplication it doesn't matter, them being recursive, but we must reverse the operation order for subtraction and division. Let me clarify what I just said with an example:

Table 5 - Subtraction and Division

Common Notation	Postfix Notation (PRN)	C-like Notation
10 + 5	10 5 +	add(5, 10)
(10 + 5) * (10 + 2)	10 5 + 10 2 + *	multiply(add(2, 10), add(10, 5))
10 / 2	10 2 /	divide(10, 2)

We could have thought, from my earlier explanation, that 10 / 2 would actually be written as 2 10 /, because, following the recursive algorithm for addition or multiplication:

Algorithm	Application
0. Let X: 1. a ← next_factor 2. If a is a multiplication 2.1. b ← X() (recursion) 2.2. c ← X() (recursion) 2.3. Return b times c 3. If a is an addition 3.1. b ← X() (recursion) 3.2. c ← X() (recursion) 3.3. Return b plus c 4. If a is a division 4.1 b ← X() 4.2 c ← X() 4.3 Return b / c 4. If a is a subtraction 4.1 b ← X() 4.2 c ← X() 4.3 Return b - c 5. a must be a value, so, return a (else)	Expression is "10 2 /" (0) X(); (1) a ← next_factor {10 2 [/]} (1') a ← / (4) Is (a="/") is a division: (4.1) b ← X() (4.1 leads to 0) (1) a ← next_factor {10 [2] /} (1') a ← 2 (5) Return 2 (returns to 4.1) (4.1') b ← 2 (4.2) c ← X() (4.1 leads to 0) (1) a ← next_factor {[10] 2 /} (1) a ← 10 (5) Return 10 (returns to 4.2) (4.2') c ← 10 (4.3) Return b / c (4.3') Return 2 / 10
Listing 6 - Non commutative operations

Algorithm

Application

0. Let X:
1. a ← next_factor
2. If a is a multiplication
2.1. b ← X() (recursion)
2.2. c ← X() (recursion)
2.3. Return b times c
3. If a is an addition
3.1. b ← X() (recursion)
3.2. c ← X() (recursion)
3.3. Return b plus c
4. If a is a division
4.1 b ← X()
4.2 c ← X()
4.3 Return b / c

4. If a is a subtraction
4.1 b ← X()
4.2 c ← X()
4.3 Return b - c

5. a must be a value, so, return a (else)

Expression is "10 2 /"

(0) X();
(1) a ← next_factor {10 2 [/]}
(1') a ← /
(4) Is (a="/") is a division:
(4.1) b ← X()
(4.1 leads to 0)
(1) a ← next_factor {10 [2] /}
(1') a ← 2
(5) Return 2
(returns to 4.1)
(4.1') b ← 2
(4.2) c ← X()
(4.1 leads to 0)
(1) a ← next_factor {[10] 2 /}
(1) a ← 10
(5) Return 10
(returns to 4.2)
(4.2') c ← 10
(4.3) Return b / c
(4.3') Return 2 / 10

Listing 6 - Non commutative operations

So, as you can see from the listing, we have to invert b and c. This should be simple enough, instead of "Return b / c", you just "Return c / b". I won't get back to the algorithm, but you can make the alteration by yourself.

Once the algorithm above is established, you can see that any PRN expression can be solved by applying it. We must turn our attention to the next_factor operation. We could parse the expression reversely, reading characters from right to left, but then another problem arises, since we'll be reading the digits in the wrong order (e.g. 10 will be read as {0, 1}). This means taking care of reversing them back to the usual order, which can make the parsing become highly complex. So instead, let's look at our algorithm once more... we need a structure that will process first the last items stored. Hmm... Last In, First Out...? A LIFO, which is a stack! And, hear me, stacks are goooood! Whenever you can implement something with a stack, do so.They usually make for nice, clean algorithms.²

Anyway, so we can parse the expression left-to-right, pushing factors into a list and, later, as X calls for a new item, we pop them out.¹

Wrapping Up

Uffs! We finished analyzing the problem, resulting in devising an algorithm to process the data, the necessary data structure and rules. By checking our reasoning above, we could create a formal process of analysis:

Gather requirements from the problem, do your homework!
Iterate in order to create a mathematical model to describe your problem. Most things are reduced to a series of calculations.
Iterate in order to define data structures that can support your algorithm. You will usually end up with lists, queues and stacks. Or some cases (on data-centric problems) you will deal with dictionaries.

This is a very high-level process for analysis. As you can see, we have not used any kind of formalism to solve this problem. The goal here is exactly that: on a day-to-day basis, you won't be required to hold a degree in mathematics (or computer science, for that matter) in order to design problems.

Next On

On the next article we will produce an implementation for the algorithm above. As usual, after having a a well defined problem and a fully designed solution, building the program should be very, very simple. But I will try to iterate over the algorithm to show programming steps, like where you should focus first, then how to clean-up the code and where you should make heavy use of comments.

Notes

¹ Veterans might have realized earlier that this model is, in fact, a Stack Machine. I refrain to mention it so that I wouldn't scare of newcomers to programming. It was extremely helpful to have read the excellent article from Eric Lippert that discussed the IL as a stack machine.

² In my particular opinion, of course. This is by no means a rule.

Recuva - A Free Software You Have To Know

2011-11-22T09:27:00.000-02:00

One day you wake up, take that long drive to the office, pour a cup of coffee and boot up your PC, only to find out that you accidentally deleted a very, very important file the day before.

This is not uncommon, right? -- files are fragile things which can vanish with the click of a mouse. Most of the time, we can confide in the Recycle Bin, but sometimes, it's gone. Maybe the option is to create a new one, and lose lot's of time redoing something. Other times, well, you just cry for a bit - no way to get back what you lost. So you move on.

Recently, however, something even worse happened to me: while aumatically updating my work notebook to Windows 7 I lost all my files. I didn't had an recent backup for many, many items. Of course, critical work stuff was safe -- we use SharePoint, Mercurial, etc., so there was no immediate risk, but some files -- annotations, stuff like that -- were lost.

Having no choice other than trying to recover the files, I started looking over the net for an application that would be able to help me achieve that. You'd be surprise with the number of apps out there that intents to do exactly that. But most of those applications simply don't work... maybe because they depend on a specific API from other versions of Windows or something like that. The ones that might work are paid software with free trials available, but then the trial doesn't work and I won't pay for something I don't know if works.

I thought all was lost. Many documents, projects and personal files, all gone.

And then I stumbled upon Recuva.

The first thing to know about Recuva is that it's completely free. Indeed, you can donate money to Piriform, but that entirely up to you. This utility enables you to scan the disk for deleted files by file type, and it'll list everything it finds

The interface could have been a bit nicer, but other than that, you have all the options that a good recovery software should have. For every file it finds, it gives you a rating of "recoverability" - some files are found, but can't be recovered since it's contents are corrupt. And, of course, you can filter the list to show only recoverable files.

Recuva saved my life. It didn't do any miracles - some files were gone since the Win7 update copied over them - but those that the tool found where enough to save me hours of work. Clearly recommended.

Careful with the C# "as" operator

2011-08-20T13:37:00.004-03:00

It's very common to use the as operator instead of it's "ugly cousin", the explicit cast. The reason behind this is that as appears to be more clear to the reader, demanding less cognitive effort from the mind.

1. Using as

1:    Panel getSomeElem()  

2:    {    

3:      var some_ui_elem = this.Children[0]; // Assume at least one element     

4:      return some_ui_elem as Panel;    // Using “as”  

5:    }  

6:    void AnotherMethod()  

7:    {  

8:      var panel = getSomeElem();           

9:      panel.Height += 100;         // A  ...  

10:    }

2. Using cast

1:    Panel getSomeElem()  

2:    {   

3:      var some_ui_elem = this.Children[0];  // Assume at least one element     

4:      return (Panel)some_ui_elem;           // Using a explicit cast. B  

5:    }  

6:    void AnotherMethod()  

7:    {    

8:      var panel = getSomeElem();  

9:      panel.Height += 100;    

10:     ...  

11:   }

The difference between both operators is very clear. The cast immediately throws an exception whenever the object can't be cast to the specified type, while the as operator will only return null.

One could imagine that returning null is better. And actually, if the caller (or the rest of the code) is prepared to get a null, than you should go with as. But that usually isn't the case: we don't usually write code expecting stuff to be null. Moreover, the method's contract implicates that an object will be returned.

Wait a bit! This is getting a little cryptic, right? In both operations, on the hypothesis that the object can't be cast to Panel, we will get an exception. So there's no difference, right?

Well, there is. The question is that the operator as will hide the error. See, on the first example above, the exception thrown will be NullReferenceException at the method AnotherMethod, up in the stack, in the line "A". Whereas in the example 2, the returned exception will be InvalidCastException, exactly at the line B, exactly where the error was originated.

If getSomeElem is a library method, it will get really difficult to understand where the exception has arisen (which was the fact that the first element of children wasn't of the expected type). A uninformed caller might come to the conclusion that the object doesn't exists (usually the case when something returns null).

In conclusion, when you need to make a cast, prefer to do it explicitly. Get used to the cast notation early. If there is a dire need to use as, then remember to always check whether the returned reference is null. Only return this value after a as operation if the method's contract explictly states that the method returns null on error.

A Vector Type for C# - CodeProject

2011-07-26T11:27:00.000-03:00

The other day I was looking for a Vector class for a C# project. I was actually wanting a 2D vector, but I've come across a 3D one which is great, so, recommended:

A Vector Type for C# - CodeProject

Customize Keyboard on Microsoft Word

2011-07-13T18:01:00.000-03:00

This one is quick and simple, but as obscure as hell:

In Microsoft Word 2010 (probably 2007 as well), hold CTRL-ALT-+ to have your cursor turn into a kind of crosshairs. Click in whatever button you want to assign a button to, and the Customize Keyboard dialog will appear.

This obscure, undocumented feature saved my life once.

Solid (object-oriented design) - Wikipedia, the free encyclopedia

2011-05-27T17:21:00.000-03:00

This is a "note-to-self". While mainly overlooked by many official computer science courses and graduations (mine included), Solid is a very important principle to apply to projects.

It should be standard practice to test every software implementation against it.

I'd turn it into a rule-of-thumb, if possible. After designing the domain classes, check for SOLID. After finishing every release of the product, check for SOLID. Nice and smart!

DTO vs. POCO

2011-05-26T17:14:00.001-03:00

This should have been clear enough. DTOs and POCO are two different things. If, by some reason, you are as confuse as I have been:

- Data Transfer Objects are objects that only have data (properties, if we are talking about C#) and, sometimes, logic to retrieve that data.

- Plain Old CLR Objects are objects that are simple -- they have simple logic to represent a real world object. They do contain methods and stuff.

I got them both mixed up some time ago (actually, a long time ago) when designing an architecture. It took me at least an year to discover that, while similar (POCOs may look like DTOs), they weren't the same. You see, I decided not to attach any logic to my POCOs, and I thought that it was "compliant" with this design principle.

Now I was reading some stuff over the matter and remembered to post it here. Someone might make the same mistake.

Validation Application Block Warts

2010-11-24T21:11:00.001-02:00

As you all will have noticed from my previous post, I'm digging deeper with VAB from Enterprise Library (4.1, not 5, by-the-way). The reason for choosing VAB as my validation framework was simply the fact that I could, by using it, remove all notion of validation from the Model classes and stick it into a configuration file.

This serves two purposes:

On a multi-tier architecture, I could make sure presentation tiers had no access to validation structures but still use the validation classes, because the validation configuration would be deployed only at the back-end, where my BLL resides.
I could lookup all messages being issued by my application on a single file. Of course this would be possible by using Resources, but that is a lot of work when not planning to localize the application.

So I delved into VAB during the last couple of days. Only to get myself disappointed.

Don't get me wrong, it's still a nice framework, but the two reasons above are linked to storing the validation rules in external configuration files. And that fails miserably because VAB won't validate ancestors rules when using configuration files based validation.

The workaround for that is to replicate every rule for an ancestor at the derived class. Which is not a real solution, since such replication will lead to errors quicker than you can say "what".

I think this defeats the purpose of using configuration files. VAB is a choice only when dealing with complex system, and on such systems, there probably will have at least some cases of inheritance.

Validation Application Block and Unit Testing

2010-11-24T17:15:00.000-02:00

The Enterprise Library VAB is a very sane way of maintaining validation rules for your Model entities. I love the idea that you can keep the validation rules in a separate configuration file, because that enables you to more clearly check what rules are being applied, the messages, etc, without having to open many files.

The problem with this approach is that unit tests will fail to open the .config is usual circumstances, which will frustrate many developer. But, like almost everything in life, there's a solution, and a good one.

Check it here.

Enlarging/Expanding a VirtualBox HDD

2010-10-19T11:55:00.001-02:00

I've been using VirtualBox as a development host for quite some time now. But I've recently ran into a problem: the HDD that I defined wasn't large enough to install all tools I need (it ran out of 20G of space when I decided I needed to install management tools for SQL Server Express 2008).

So I've looked around the net searching for how to do this. First, I'm quite disappointed that VirtualBox itself doesn't accompany a tool that does that. Secondly, most of the solutions I found were complex or involved downloading large LiveCD images. Until I found this blog, which not only compiles many links to other solutions, but provides a simple one -- the one I used and recommend.

If you're brave enough (you must be; We are dealing with disk partitions here) all you have to do is:

Download GParted LiveCD (~150MB) from here.
Define a new HDD in VirtualBox and set it to be your secondary partition.
Mount the live cd as the primary IDE controller. Make sure the BIOS in your Virtual Machine is configured to boot from the CD first (and HDD next).
Boot GParted in command line (shell) mode.
Use fdisk -l to identify the old disk and the new one. Be careful!

Usually, your original partition will be /dev/hda*, where * is a number. It can also be /dev/sda*. The new partition can have another number (higher one, in most cases) or be something like /dev/sdb.
Remember that GParted will have a partition of its on, mounted on /. Use mount to list mounted partitions.
If you try to mount a unpartitioned hdd mount will tell that you need to inform its file format. That is a good clue you are talking about the right partition.

Once you identified the source and target devices, all you have to do is dd if=[source] of=[target]. It will take a long time, since its doing a byte-by-byte copy of your partition.

Assuming your source device is /dev/hda2 and your target is /dev/hdb, the command above should be: dd if=/dev/hda2 of=/dev/hdb

Once the copy is over, all you need to do is shutdown the system, map only the new drive as the main HDD of your VM, and boot it up.

Good luck.

Better Cygwin Terminal

2010-09-08T15:29:00.000-03:00

It's been a while since my last post. I still don't have time to do it properly, but here goes a tip for those of us who use Cygwin:

Make sure rxvt is part of your Cygwin install, and update your C:\cygwin\cygwin.bat to this:

@echo off
 C:
 chdir \cygwin\bin
 start rxvt -sr -sl 10000 -fg white -bg black -fn fixedsys -fb fixedsys -tn cygwin -e /bin/bash --login -i

(If you don't want the first window hanging around)

@echo off
 C:
 chdir C:\cygwin\bin
 set EDITOR=vi
 set VISUAL=vi
 set CYGWIN=codepage:oem tty binmode title
 rxvt -sr -sl 10000 -fg white -bg black -fn fixedsys -fb fixedsys -tn cygwin -e bash --login -i

Check out this site for more info.

How to read a binary file/stream in C#?

2010-08-04T15:34:00.001-03:00

This one is simple, but helped me a lot recently.

http://www.chilkatsoft.com/faq/dotnetstrtobytes.html

SourceMaking

2010-08-03T11:52:00.002-03:00

This one is for developers and architects out there. An excellent site about Design Patterns and UML:

https://sourcemaking.com/

Recent Files on Office

2010-06-04T17:17:00.002-03:00

I have to agree that this is a very personal thing, but still, one of my favorite things in Office 2007 menus was the recent list.

You had about 20 items to choose (up from 4), from which 9 you could access using a simple key combo. It was amazing! I saved several minutes of my day that were wasted searching for files in very deep folder trees. Moreover, that was a very nice pin feature, that allowed you to hold or pin down a certain file to that list. This made sure that the file would remain in the list even if you don't access it very frequently. In short, it was a Favorite File combined with File History.

The recent file list as of Office 2007 (picture taken from here)

And what I loved the most was the fact that I could get some files very quickly. Inside Word, for example, I'd type ALT-F, 1, and wow! That timesheet that I used everyday would be open. The great advantage of not having to search is that I didn't had to focus my mind in opening the file: it was a mechanical task. Looking for files in directories requires focus because you have to scan the folder for your file.

The problem is that, in Office 2010, which I have been using for some weeks now, the Recent list is not on the "File" menu, but on a sublevel of it. If, having something open on Word, I go ALT-F, I get:

Some names where censored on purpose

To access the Recent files list, I have to click at the Recent item on the left-side menu! Or the other hand, the features that I'm seeing here aren't really that useful. In fact, I don't recall ever using them on Word 2007. So, another tip for MS Information Architects: Verify which features are mostly used and make them more easy (direct) to access.

Another Bad UI

2010-05-28T15:07:00.001-03:00

Microsoft is the champion of Bad UI design... mostly because MS has so many end-user softwares that are very spread. So, it's not really their fault. However, I find some mistakes more serious, mainly when we are talking about the OS. And let's remember that Windows hasn't changed a real lot in the last 15 years.

The bad design was in the Copy File box:

Names ommited due to privacy issues

It's bad enough that for some reason the file transfer had stalled. But I was copying many files, one at a time, to this destination folder. Now, one of the "Copying..." boxes was clearly telling me one of the operations have failed, but which? Where is the name of the file? When copying a file from one place to another, there are 3 informations that are crucial to the user:

Which file
From where
To where

(2) could be ommited if files in our HD had unique names, but since we end up naming a lot of stuff like "Todo.txt", "tasks.txt", "prices.txt", "list.txt", we need to know which of them we are talking about. Older boxes like these solved the space trouble by including additional information in a ToolTip. But in Vista, MS forgot that the filename had to appear somewhere.

I had to start over and check each file to see if it was correctly copied.

Microsoft Project tutorial: Duration and task types

2010-05-20T12:54:00.003-03:00

This article might be helpful for those of us that are sure there is a form of Artificial Intelligence inside Project.

Opening Visio 2007 docs in Individual Windows

2010-04-23T14:42:00.004-03:00

I repeatedly disagree with Microsoft UI designers. Ok, they think it's nice that Visio treats many diagrams with a single instance. That I can live with. But shouldn't they enable the user to quick swap between them, maybe by using tabs, etc.?

Anyway, Visio is actually a great tool, so I'm not ready to ditch it just yet. Not surprisingly, there's a way to make sure Visio opens a new instance every time you open a new file, which results in a taskbar item for each document, which essentially mimics the effect that I desire, because it enables the user to quickly see whichs files are open. Not surprisingly as well, the method it's obscure, requiring some tweaking with Windows registry:

Open Visio and go to Tools->Options, select the Advanced tab and check "Put all settings in the Windows Registry".
Open regedit by typing regedit in the Windows->Run interface.
Make a registry backup by selecting the upper node in the tree on the left panel, and selecting File->Export. Make sure to add a date to the file, so that you now how long it was since the backup was made.
Navigate the left tree to HKEY_CURRENT_USER/Software/Microsoft/Office/12.0/Visio/Application.¹
On the right panel, find the "SingleInstanceFileOpen" value. Double click it, and change it's data from "1" to "0".

Just one thing. This will increase memory usage by Visio, since each document now has to run a full application.

¹ - This applies to the 2007 version of Visio. Other versions might store the value somewhere else, so if you are running something different, try Edit->Search and look for SingleInstanceFileOpen, but make sure this is a Visio value.

What Every Computer Scientist Should Know About Floating-Point Arithmetic

2010-04-19T19:09:00.000-03:00

Nice article about float points. Too bad the reading is complex and slow, but I recommend it to every programmer out there.

Enabling ICS

2010-03-26T16:20:00.000-03:00

I'm on fire this week. Another small help for our everyday use that I decided to post here since it took me quite a while to find it on the net.

I was trying to enable ICS (Internet Connection Sharing) on Windows Vista and always got this error message:

"An error occurred while Internet Connection Sharing was being enabled.
(null)"

Well, I Googled it and found this post which gave the solution, which is to enable the following services:

Application Layer Gateway Service
Network Connections
Network Location Awareness (NLA)
Plug And Play
Remote Access Auto Connection Manager
Remote Access Connection Manager
Remote Procedure Call (RPC)
Telephony
Windows Firewall

In my case, the Windows Firewall was the culprit. It's not ideal to have to have Windows Firewall running just to enable ICS, because I already have Symantec Firewall protecting me, so I hope Microsoft correct this sometime in the future.

Google in China

2010-03-23T19:11:00.000-03:00

All this stuff about Google standing up to China's government, Chinese hackers et cetera has left only one question in my mind: why Google's front page is different in China?

What happened to File Assossiaction under Vista, Seven?

2010-03-23T16:40:00.000-03:00

Back to my help-you-do-it articles...

One thing bothered me for a while: our dear Microsoft removed the file associations item that was under the Tools Menu.What the hell? I never quite understood why MS does that sometimes. Information Architecture is very important, and regrouping items might make things better for the user. However, those grouping and organizations should reflect what the user (us!) believes to be the right way to sort the information.

I mean, when asked the question, "where is the right place to put <something>?", the answer is usually "where most users think it will be!". So Microsoft, where do *you* think your users look for file associations? Where it has been for more than a decade, under the Tools menu!

When I was looking for it, to fix an association that another badly planned application decided to break, I immediately went to the Folder Options, under the Tools Menu and looked for the association, which was no longer there.

Before I panicked I decided to Google it, and found out that the associations are now under a specific application called Default Programs, under the Control Panel.

The Default Programs application is a more user-friendly version of the old File Associations tab. It lets the user change the default program that will open an file (based on the extension, as it's the custom in Windows), change the association between file extensions and programs, set the autoplay defaults, and even use a profile-like thing to rapid switch configurations for associations (which is done in order to enable the user to quick return to a Microsoft setting, of course).

So far, so good. If you need to reconfigure your file associations, you should look at this wizard.

HOWEVER, where is the "advanced" button? None. Microsoft thinks all of us, users (even those with a Enterprise Version of Windows Vista) are dumb. So there's no way to change how the application is executed, like, for example, which parameters would be provided when calling a program to open a certain file. in my case, I was simply trying to tell windows that Java jar files are opened by calling java -jar JARFILE.

Well, enough complaining. How do we do it? There are two shell utilities, ASSOC and FTYPE, that enables us to do it. If changing the place of the interfaces was a bit unfortunate, I must say that the new solution is way better. ASSOC and FTYPE lets us create a N to N association between file types and extensions, and it's much more clean than the way it worked with the old interface.

You must take two steps in any order when defining the associations:

Define the File Type
A file type is a kind of "profile" for your file (I think file class would be an even better name). You name it anything you'd like and informs how it's opened. On my Java JAR example:

FTYPE jarfile="C:\aplic\Java\jre6\bin\javaw.exe" -jar "%1" %*

where %1 is the filename that Windows will gladly pass to your application and %* tells windows to "pass everything else to the program the way you received it". The last one doesn't make much sense in Windows, but the truth is that the shell will also use this list to open files, so if you simply type the filename on the prompt, you end up opening the file.

Create the Association
Now, for the association itself,

ASSOC .jar=jarfile

which is quite intuitive: you tell Windows to threat files with .jar extension as jarfiles.

Sorry Chrome

2010-03-09T17:29:00.001-03:00

Should I be surprised that Chrome doesn't work with this GOOGLE website?

Elements and Attributes in XML

2010-03-09T17:27:00.001-03:00

Today I got myself wondering about when to use differences and attributes in XML. The general understanding is that the question is very philosophical, depending on how your system is designed and, even more, on how you understand the data in your application.

However, the subject isn't new and there are a lot of articles on the web that already deal with the issue. So, instead of repeating what other, more experienced people already wrote, I'd rather appoint readers in the right direction:

Elements vs. Attributes in w3future

What About Google Wave?

2010-02-12T11:37:00.001-02:00

I'm a technology enthusiast. Let me rephrase that: I'm a software enthusiast. Every time I can lay fingers on a new piece of software, I do. I have installed and run VirtualBox on my computer, just for the sake of it; I use Cygwin daily. I don't need but use OneNote because the concept is cool. I'm currently learning Powershell scripting and my navigator of choice is Chrome, just because Google decided to use processes instead of threads. And, of course, when Google Wave was announced at Google I/O, I couldn't wait to put my hands on it!

At first I was, of course, astonished. Google delivered almost everything the presentation first promised, which was indeed a lot. At first look, I found the tool to be very similar to a web forum. I even guess that was one of the goals, uniting the community activity of forums to email. As a tool, everything was sleek and had that "Google touch", which means good quality, a lightweight interface, strange coloring, etc. The site makes extensive use of AJAX to offer a seamless interface and dynamic loading of data. The load time for the items are as expected: good as long as they aren't cluttered with posts.

The best features are the phenomenal integration with YouTube! and Gears, the possibility to upload files to a persistent location which makes sharing that more easier (even though I haven't really discovered the size limit for each file) and the formating, which is very present, so users are encouraged to write visually rich "articles". Finally, some of it's real-time features can add something to the experience, even though I think that is far from being one of the product's best qualities.

But, whereas technically Google Wave stands out as a very polished tool filled with features, conceptually, it's flawed. Google aimed high and large: Wave was going to replace e-mail, forums, IM, etc -- almost every well established electronic communication tool out there. And the application had a list of features to make up for each of those tools that we use. Problem is, as it's usually the case with swiss-knives kinds of software (or any product, for that matter), Wave accomplishes almost none of the replacements it proposed itself to:

When compared to forums, you will discover that not being "public" makes Wave less than useful. It's cool to discuss about that new movie with your friends, but community boards will enable you to get a different point of view every now and them, so important to discussions.

And then Wave should replace e-mail. E-mails chains are like stacks of information. Everyone adds something to the top, and you "can't" change what already has been done (on some cases, e-mail is more a tree, because of simultaneous replies, but that doesn't happens very often). Wave, however, threats information like a "live" document, which is compatible with the Collaboration Age (or Collaboration Wave, as one might call...). So what you said yesterday may change today, or even cease to exists. It's confusing. There's a feature that tries to solve (patch) that, called "history", but it's like a pain to use it to check what you missed. On a e-mail, you just have to scroll-down the screen a bit and there it's, that last piece of info that you forgot to read. On Wave's History, you will keep going back and forth until you discover what was there but isn't anymore.

And IM? Well, Google shouldn't even have proposed that. IM works because you have a small icon on your desktop that you can double-click in order to get a list of contacts and start talking with whoever is online. It's that simple. On wave, to IM, you use the IM panel, which is just like a sized-down version of Google Talk... So, why would you? Isn't it easier to Google Talk anyway?

All things said, I must add that the worst part of Google Wave is the problem that, for a dynamic application, the topics are treated very statically. Let's say you send your pals an e-mail about that latest game for Playstation. You start talking how it reminded you of a certain movie, and before you know, your friends started talking about movies. After a while, the subject changes slightly, after another friend adds that this actor was once arrest for drug use, and then you're discussing the lives of the famous. That's is a bit chaotic, indeed, but so are conversations. They rarely ever turns into what we wanted in the first place... once they begin, they become live things that change whenever something different is said, because that's the way the brain works, by making free association of ideas. When you try to have this same conversation in Wave, however, things get a bit confusing. Since Waves are so clearly persistent, you look at them that way. You start a Wave about a trip to Europe, you hope people only talk about that in there, which doesn't happens. Someone ends up saying something about a bar or restaurant, someone remembers about another one in your own city, and all the sudden your Wave about Europe is now arranging a dinner with your friends. And worse, since you can post anywhere (Waves are flattened-down trees), the subjects are intertwined. One can argue that this would resemble our thinking process even better than e-mail, but as a tool, it gets messy.

All-in-all, Google has offered us a nice product, with nice features, that is useless only because all its older brothers are more effective at what it does.

Why COBOL Is Bad For Your Health

2010-01-21T17:40:00.000-02:00

Before you think that I'm going to continue one of the eternal developers discussions like Windows x Linux, or C# x Java or even OGL x DX, I'm not. COBOL is a useful language and will remain that way for a very long time. It has and keeps serving its purpose, which is to be a language targeted at non-programmers, mostly business analysts, with very few or none programming knowledge whatsoever. What I'm about to state here are the deficiencies of COBOL: being business oriented has its cost and COBOL pays dearly for it. Also appreciate that I have good knowledge over COBOL, Mainframe, and Batch architecture. However, I was groomed in C/C++ and specialize in distributed systems, so I have a reasonable understanding of both worlds.

Recently a fellow in my team asked me why I hated COBOL so much. To keep things short, my answer was that I did not hate COBOL at all, but I thought that there were better languages which could do COBOL work better; I stated that COBOL syntax might be easy and simple, however, COBOL programs are semantically obscure and can often lead very bad algorithms. I'm now going to explain why I think that.

Remember that I'm not a doom-sayer. COBOL isn't dead, nor is it going to die. It has its purpose, and it does it well enough. People will keep learning COBOL for a long time now, and many enterprises will continuously grow their mainframe platform.

So, without further ado, let's give you my reasons why I believe that COBOL is bad for your health:

SECTION A - CODE SAFETY:

I. All Variables Are Global

It probably goes without saying (at least to any weathered, non-COBOL programmer), that you shouldn't use global variables in your programs. Globals are bad for your health because it's hard to predict their value, the reason for that beings that every single instruction inside the program might modify it.

If your program has less than two hundred lines and variables follow good naming rules and if you're not using redefines, maybe you can find out where the variable is accessed and predict its value. But in a world where the average COBOL program has way more than ten times that number of lines, you are in for a very hard "mind compiling" experience.

Moreover, there's a have a side-effect of variable cramming. Whenever a programmer needs to extend or fix the source of a COBOL program, instead of using the variables that already are there (since he can't know where the given variable is accessed), he declares a new variable. The effect of this is that the source end up having more variables than effectively necessary and gets even harder to read. Add to that the fact that COBOL doesn't allow variables to be declared within procedure code (like old C), and now you have this programmer hell: many variables whose declaration are very far on the code from their use spot, which means a lot of scrolling up and down the source.

II. Variables Aren't Type Safe

Type safety is a very complex subject. Many languages that are perceived as type safe actually aren't -- C/C++ can cast anything to void, and void can be cast to anything -- but COBOL goes way beyond that when it gives programmers REDEFINES. REDEFINES allows anything to be seem as a different type at compile time, and is, in many ways, a cast. One can argue that C/C++ presents us with a similar structures with unions. However, for some reason, C/C++ programs hardly ever use unions, preferring to have a bytestream that is then copied to a new instance of a certain type.

Besides, COBOL also have "untyped" variables, called group items. Group items in COBOL are similar to C structs, being a definition of a group of variables that are aligned together in the memory. However, in COBOL, those group items doesn't have a defined type, and the compiler allows that any date be moved to such group or from the group. There is no runtime boundary checking as well, so you can easily overflow the area. What COBOL does for you instead is area truncating. It's completely left to the programmer the responsibility of knowing the types fit.*

II. Variables Aren't Really Typed

This one will probably be the most polemic point here. COBOL use a typing system that includes mainly two types of variables, numeric and text. Numeric variables can be of COMPUTATIONAL type, which means that they allow numeric data but such data is stored on a different way -- compacted. The first criticism here is that, for a language called 3GL, COBOL, exposes a lot of the underlying implementation to its programmer, which has to know the differences between compacted COMPUTATIONAL data and "common". Of course, there are historical factors that led to this implementation, namely, the fact that storage was way more expensive when COBOL was conceived. But using this as an excuse only proves that COBOL is obsolete and should be dumped.

SECTION B - Code Structure

I. Where You Write Your Code Matters
COBOL still inherits a lot from punched-card days. In COBOL, code can only be contained between column 8 and 72, and column 7 is reserved for "indicators", that can help you inform the compiler that the following line is a commentary or a continuation from the previous line. Add to that the fact that some commands need to start on what COBOL calls AREA B. Area B starts at the column 11. This means that you have only 61 characters to input commands, which are very long in nature already (you need a least 11 characters to write an attribution, for example). And remember that variables tends to have lots of prefixes and suffixes, because the COBOL scope member operator OF is never used.

II. Periods Are Both Scope And Statement Terminators
Another one of COBOL strange behaviors that will make you shiver. In COBOL, you can finish statements with a period ("."). You can, because most of the time you don't need to. Most of the time, because sometimes they are necessary. Already confused? Well, it gets worse. In COBOL, you also close scope with a period. So, if you begin an IF construct and stick a period just after the first statement, the scope is terminated and whatever comes afterwards is considered outside from the IF.

So, if you decided to stick periods after all sentences, you can't. So you decide to abandon periods, and be on the safe, never ending a loop or scope accidentally... but, just like we said, you can't.

III. Idiosyncrasies
COBOL is a champion when it comes to idiosyncrasies. For example, assignments in COBOL are written as MOVE variable TO variable. Moving is usually conceived as taking something from one place and putting it somewhere else, but assignment works by copying the value of a certain variable to the value of another one, and that's exactly what the MOVE operator does in COBOL.

In sum...
There are a lot of reasons why COBOL should be avoided at your enterprise. Sure, you can have a person trained in COBOL in less than a week, but how long will you take to remove bugs from his code? How many bugs will appear in the future? COBOL is a counter-productive language, that encourages bad developers to write bad code.

* COBOL has evolved during the years, and so have the compilers. I wouldn't be surprised if there was a compiler directive that allowed such checking to be made, but I must say that I never saw anyone using it.

Variable Scoping In Bash Functions

2009-10-02T17:44:00.000-03:00

Quick and dirty, people. Today I was testing some complex bash scripts that we wrote on my current project assignment -- those which should have been a python or pearl script to begin with -- and bumped into a problem concerning functions and variable scope.

Since I'm mainly a C* programmer (C, C++ and C#), my shellscript looks too much like a common program, admittedly. This means that I use a lot of functions. But there's a catch: variables used in bash are automatically global. So, if I execute the portion of code below:

#!/bin/bash
function test()
{
    value=123
    echo $value
}
value=321
echo $value
test                          
echo $value

I will get the following output:

321
123
123

Which isn't what I intended. So, I found this nice command that was secret to me, called "local". Variables in bash can be declared, and it's scope can be determined by using this command. So, the following script:

#!/bin/bash
function test()
{
    local value=123
    echo $value
}
value=321
echo $value
test
echo $value

Which would produce:

321
123
321

Which would be exactly what I desired.

ThinkPad T400

2009-08-19T12:52:00.003-03:00

Today I got my "new" Lenovo ThinkPad T400 as part of a hardware upgrade program from Accenture. Every 3 years (in my case, 2,5) Accenture upgrades our notebooks, since, of course, they get aged somewhat fast after intense use. And, in my case, they also get outdated because customers like cutting-edge technology, and cutting-edge technology needs cutting edge hardware to be developed upon.

So, I got this business oriented Lenovo ThinkPad T400. And I've decided to blog about it, because I'm tired of complaining to the walls (or to my girlfriend). Considering just the hardware, this notebook is top value. Good HD (160GB 7400RPM), nice RAM (3GB), the case seems sturdy, and the battery life is amazing. Besides that, the screen has a cool lamp that lights the keyboard, in case you have to type in complete darkness and can't find the keys. Cool, but not sure if it's useful.

Now, for the rant. The keyboard plainly sucks. I have no better term so, sorry purists, but this is it: the keyboard sucks. Every key that isn't the default QWERTY has a terrible placement. Lenovo has put a lot of work into making this notebook very small, and reducing keyboard's size occupation was probably #1 concern. to achieve this, some keys are way smaller than the others, like, for example, the Windows Key, which is narrower than the rest, may escape your fingers (if you type on such a hurry as I do).

The worse, however, remains for the "Fn" and ESC key. Fn, for those who are new to the notebook world, is a special function key that works similarly to CTRL or ALT -- you need to hold it and press a certain key to access special notebook functions. The Fn key was placed just below the left-shift key, just where the CTRL should be. Now for those who, like myself, use the side of the small finger to hold the CTRL, this is a nightmare. Fn has much less function than CTRL, but the key is in a more reachable place.

In my case, the worse part is that I use a lot of CTRL+Right and CTRL+Left to skip words when typing, but on the Lenovo, Fn+Right and Fn+Left skips a track on whatever multimedia player is running (it's a Windows' multimedia key). I still haven't learned how to disable this function.

Also, the ESC key is sitting on the top of the board, above the F1 key. I find myself reaching for ESC and hitting F1 instead, which usually means opening Help. It's annoying. Since ESC is a big part of Windows, this is almost worse than control. Luckily, I use it less than I thought and it's easier to get used to it.

Finally there is the Track Point in the middle of the keyboard. This one is hard to decide -- there are people who loves it, but on my opinion, I have the touch pad, thank you very much. My complain is that I end up touching it when travelling over the keyboard. This is annoying, but if it was the only problem, I wouldn't care about it.

For those of you using a Desktop, think how awful would it be if you couldn't change the keyboard, if you were stuck with a ESC in a wrong position. Now, think about it, but without a mouse. Sounds like hell, doesn't it?

Quick Tip: SourceSafe Internet Plug-in

2009-01-19T16:50:00.000-02:00

Hello crowd,

I've AFK (at least, in a blog sense) for quite a while but now I think I will have more free time. I'll begin this new year with a quick tip:

I use Visual SourceSafe a lot -- it's the our default's SCM solution -- and I've ran into a problem some time ago: I wanted to use the internet (HTTP) version of the program. The reason for that was that our VSS database was stored on a Windows XP machine it's impossible to connect more than 10 simultaneos people to share in those OS. So, I thought that maybe the HTTP version of the plugin wouldn't have such restriction.

I was wrong.

Anyway, problem is that I didn't know how the plugin worked:

First, the plugin is only for Visual Studio, which means that visualization through the VSS client still is done through Windows Folder Sharing.
IIS HTTP has the same limitations as WFS.
The plugin is configured on the Options->Tools menu in Visual Studio, under Source Control -> Plugin Selection, which enables one to choose between common (WFS) or internet (HTTP) communication.

Of all the info on this post, the third one is the most important, since after I configured the plugin (clicking such option on a message box that poped-up), I took me almost a day to find how to turn back to the WFS plugin.

Do you have to know English to be a Programmer?

2008-11-21T16:33:00.000-02:00

This one comes from a large chain of events, and since I like continuity, I am posting about it. This question, “Do you have to know English to be a Programmer?” was a subject on a blog post, http://hype-free.blogspot.com/2008/10/should-we-use-english.html. It was sppoted by me on Scott Hanselman’s blog. It is a big question, and a very important one at that.

As you should know (just by looking at my right sidebar), I am a Brazilian, which means my language is Portuguese (which should be called “brasilianese” or something), and I began learning English when I was only six years old. I have been interacting with the language ever since.

Therefore, my knowledge of English is prior to my knowledge of programming, which makes my opinion less relevant in the matter somehow. However, why did I learn English in the first place? I think it was about the same reason that would lead a programmer to learn it – I loved to play video games back in my childhood, and those only came in English. Programmers, I believe, also learned because of a similar fact, software usually come in English. There are exceptions – mainly for those who live in more developed countries or regions, like Europe. There are better efforts at software localization nowadays, and that means a lesser necessity in dealing with non-native language.

Nevertheless, I must come back to the phrase – “Do you have to know English to be a Programmer?” I think that such question is very gray, since we have not stated what is “know” and what is “Programmer”. If anyone who writes a hello world or a simple script is to be considered a programmer, then, in my opinion, the answer is no, you do not have to know English for that. But if I rephrase the question:

Do you have to be able to read some English to be a good programmer?

The answer is a very big YES! Why:

· Main technologies researches that happen worldwide are conducted in English. Researches make this choice, because their product needs to have a reach as large as possible. Sure, you could wait for someone to translate a given book or article, but good programmers should know about newer technologies as soon as possible, to be ahead of competition.

· Translations are, often, very poor (all your bases are belong to us) and small variances can lead to big mistakes.

· As an engineer, I love standardization, and I’d choose English as the one. Some could argue about the fact that Spanish is one of the most widespread languages in the world, but I guess they’re missing the fact that many Spanish programmers already know English, while the inverse isn’t true.

· Most computer languages are in English (actually, I don’t know of any in another language).

Communication is very import in this age, and we need a language that enables a standard effective one. On computer-side, this one seems to be XML (which, by-the-way, is in English). The human counterpart is English.

However, I do not mean to say that there are not good programmers who cannot understand English. Every rule has exceptions, and this one is no exception (unless there is a exception… wait…).

What do you think?

Excel Tips & Tricks I - Removing Duplicates

2008-10-22T05:00:00.000-02:00

And one more article is blooming now. For a time I've been thinking about this specific article: how to do some [basic] stuff in Excel. (I call it 'basic' because you probably will use it very constantly.) Stuff that is actually helpful, and simple to do -- not like the previous article that was a bit more complex than first intended -- but actually so simple that you need not be an Excel expert to do it.

First of all, why I should be talking about Excel? I'm specialized in software engeneering, so maybe I should keeping talking about scripting or maybe even programming. But the truth is that Excel is the most useful tool in my computer, way above any IDE that I have here or scripting tool or whatever.

Why? Excel is capable of scripting, for one thing. Second, there's no more intuitive way of organizing data for a human beam than using a bidime

nsional table. Finally, Excel can help us format this data in a very professional (which means "pretty") way, automatically.

I. Removing Duplicates

That said, one of the bests uses for excel is to gath

er data... maybe records from a report, maybe names from a list, whatever. This data often contains duplicates that need to be removed so that the analisys can be made. There are many different ways to remove those duplicates -- and in Excel 2007 Microsoft has finally included a functionality that does this for us.

But since most of us still use Excel 2003 or less, it's very important to know how to best do this. So, here's a very simple tutorial:

1. Define the Key Column

The first step is to define which column(s) will be used in the duplicated comparison. Let's ilustrate: you have a employee list. On column A is the employee name, on B his last name, on C his carrer level name and on D his montly wage. You know for a fact that someone screwed up the report and there are duplicates records -- the same employee appears more than once on the list. It's your purpose to create SERIAL NUMBER

S for your employees, but first you will need to clean-up the list.

However, you also expect to have duplicates first names in your organization, after all, we are talking about a lot of people. So to determine that th

e record is a duplicate of a previous one? You will have to join the Last Name and the First Name to create a third column. This column will be called your KEY column, and it's where we check for duplicates.

Example Sheet

In our example, the "KEY" column is the concatenation of both NAME and SERIAL NUMBER. We create this in the E column. To concatenate both values, you can either use the CONCATENATE function or just the join operator (&); I preffer the latter, so your cells should have the following formula:

=B2&A2

...which is self-explanatory. This column should not have duplicates -- and this is how you ensure that:

Sort your KEY column (E) in Ascending Order.
Create another column, labelled DUPLICATED?, which should compare if a given item from column E is equal to the previous one, using the formula:

=E2=E1

Resulting in true for whatever lines are duplicates from the first one.
No you can filter you sheet to select only duplicated lines:

Before filtering...

...and after filtering.

Now, all you have to do is exclude the duplicated lines. To do this, select the first line (in the example, click on "Henry"), then, holding both CTRL and SHIFT, press "down" once, which should select all cells in A. Now, hold SHIFT only and press "space". This will select the whole line (even empty cells). Right-click the selecion and choose "Delete Row".
Clear the filter and the duplicated will have disappeared.

That's all for this tip. It's quite easy to do this when after you did it two or three times, and it's handy. Users of Excel 2007 might even preffer to remove duplicates this way since you will see exactly what you are removing.

Next week I will post another tip, this time on coloring odd lines in a document.

Microsoft Always Think We Default To "Stupid"

2008-09-06T17:37:00.000-03:00

While I write my next real blog post, a minor rant (and something to remember when you are developing an application):

Microsoft newer products, since the complete widespreading of Internet, which would begin by the end of the last century, are PARANOID. First of all, they assume the user is a complety newbie that will do everything wrong. Secondly, they assume everything outside (and, sometimes, inside) the computer that can be harmful will be. In other words, MS has closed all doors to your computer that they could imagine, so that no hacker could exploit them.

Of course, all this paranoia accomplished nothing. MS browsers, OSes and Applications are still vunerable to exploits. But it also made the life of the user (us!) much more difficult -- we have to click a lot of pop-ups to let our applications make anything deemed harmful, like downloading a file from the internet or modifying the system register. But today, I've come to the best example of how this untrusting paranoia can be paradoxal:

I use MS Project server on my projects and today I decided to try to integrate it with my Outlook 2007. So I navigate to the Project portal and browse to the web page where I can download the plugin. Naturally, this is a ActiveX plugin that is unsafe accordingly to Microsoft, so when I click the button, I get this message box:

Now, MS asks me to disable all that security paranoia, and just be careful. See the deadlock they've created?

How To Count Lines Of Text (LOC) in Documents

2008-08-07T14:12:00.000-03:00

Suppose you have a (large) number of files and you want to know how many lines of text each contains. In computer programming that number is know as Lines-Of-Code or LOC and is a measurement of code complexity. Or maybe you are a writer or editor and separates chapters of a book in different files. Or maybe you have this data sample that came in plain text files and you need to know how many entries (records) each sample has.

There are, of course, many ways to do it. The most straightforward one is to simply open each file on your preferred text-editor, be it notepad, notepad++, UltraEdit or whatever and then use CTRL-END to go to the end of the text, then simply look at the current line number.

This option is ok for a small set of files, say, ten or fifteen. But if you have a larger set, fifty or more, it probably will take too much time to do it. So, let's look at alternatives:

I. Using a DOS Batch

This option is simple and very quick to build. Experienced VBScript writers will prefer the next one since it's more flexible, but common users should default to this. They are very similar and have about the same basic result.

The Basics: The DOS Script is a scripting format for DOS (which now is called the Windows Command Prompt). Old timers will remember dealing with .bat files in the old DOS days, usually to pass parameters during program call. But, in fact, DOS bat files could do much more even back then, and now they are a very handy tool to any windows user that doesn't want to deal with the intrinsics of VBS programming.

Restrictions: Can only be applied to non-formatted files.
Downsides: It can only count the lines. VBScript solution might apply filters, etc.
Recommended: If all you need is the total number of lines for each file.
How to:

A DOS bat is a text file with the .bat extension (for instance, example.bat) that contains DOS native commands. The bat is purely interpreted -- it's as if each command is being typed separately by the user on the command line shell. To use it, open a text file on your favorite text editor (notepad, UltraEdit, notepad++, etc) and save it with the .bat extension (countLOC.bat). It's easier saving the file on c:\ so that we can access it easily from the command prompt. The first example will only count the lines of a single text file:

countLOC.bat (1)

@echo off
REM The following line sets delayed expansion, which is used to
REM make sure variables have dynamic value.
SETLOCAL ENABLEDELAYEDEXPANSION
REM The following FOR loop reads the file line by line
FOR /F "tokens=*" %%j in (data\text.txt) do (
set /a numLines=!numLines!+1
)
echo data\text.txt !numLines!

To ran the script above, you will need to open the DOS command prompt (now simply called command prompt), and type the name of the script:

Open the DOS prompt (Start → Run, "cmd").
First switch to the disk partition where the files are by typing the letter of the partition followed by a colon, like "c:", then enter.
If your shell tells you you're on a different folder, just type "cd \", which will bring you to the root.
Run the program by typing its name on the prompt:

c:\>countLOC

Now, let's examine the code. The first line disables echo, which means that commands itselves won't be displayed on the screen, only their output. Remove this line if you want to debug the bat, but keep it afterwards so that display is kept clean.

The lines 2 and 3 begin with REM, which is short for REMARK. Use it as a commentary mark (anything following REM is ignored). SETLOCAL in line 5 does what the commentary section explains: on DOS bat, if you declare a variable (which is done through a SET command), the variable is static. It means that it cannot be modified during execution of commands such as the FOR loop.

Finally, it's necessary to understand the FOR command. FOR is a very handy tool that enables script writers to do repeating tasks a certain number of times. It's help is very comprehensive (type c:\>for /?) if you want a description of its uses. The most interesting format is /f, which uses files (or text, actually) as input variables. The command will scan the file, "data\text.txt", line-by-line. Usually, this would be used in composition with another command, to extract some information from the file. In our case, though, we use the code on line 9 that will increment the numLines variable when executed.

The /a option in SET tells the command to interpret its input as a aritmethic expression, so line 9 adds one to numLines. If you ran the above script, you will see a output like this:

C:\>countLOC.bat
data\text.txt 9

The next goal is to do this with all the files inside a certain folder. Take a look at the next version:

countLOC.bat (2)

@echo off
REM The following line sets delayed expansion, which is used to make sure variables
REM have real dynamic value.
SETLOCAL ENABLEDELAYEDEXPANSION
REM Get DIR from input
SET DIR=%1
for /f "tokens=*" %%i in ('dir /b /a-d %DIR%') do (
for /f "tokens=*" %%j in (%DIR%\%%i) do (
set /a numLines=!numLines!+1
)
echo %%i !numLines!
)

I've highlighted the differences. As you can see, we've nested the FOR loop in another FOR loop. What I'm going to do here is to repeat our previous loop for each file in a given folder. I use as an argument to FOR the command dir /b %DIR%, which pass the output from dir command as a text file to FOR, so each file in the folder is read. The /b switch tells DIR to run in bare mode, which just output files name, without header or trailer and the /a-d tells it to not display directories.

Finally, I've "parametrized" the folder name. DOS bath can receive arguments from the command line through %1, %2, etc. So, the user must pass the folder name as an argument to the DOS bat the folder name, which is c:\data in our example:

C:\>countLOC data
asd.txt 7
cassi.txt 10
DBD_All.txt 8926
SourceSafe.txt 8927

The script is ready. All you have to do is copy the solution from countLOC.bat (2) and save it with this name. In case you want to learn more about DOS scripting, point your browser to Rob's van der Woude Scripting Page.

II. Use a VBScript

Using a scripted language to do it is probably the best way to go, since you can customize this solution to whatever you want. This solution is based on a article by Hey Scripting Guy, from MSDN. I've used it more than once, to count LOC from source files and records from data files.

The basics: You will need to write a very simple VBScript to do it. VBScript isn't the best scripting language out there, sure, but has a great advantage -- any Windows installation comes with it. To 'program', just open your prefferred text editor (we love text editors, don't we?) and sabe the file as something.vbs (as usual, "something" is anything you want). Then double click this file in Windows Explorer -- it will be compiled and ran.

"Compiled?", you ask. Yes, VBScript is, oddly enough, a compiled language. This means that your code is first fed into a compiler, generating a 'binary' of some sort (not necessarily native machine code) before it runs.

Restrictions: Can only be applied to non-formatted files.
Downsides: VBScript programming is a bit complex for newbies.
Recommend: If you want to apply some filters on the file, like verifying if a line is a comment, etc.

How to:

So, let's write this program. First you must understand that, to access files and other Operational System functions, VBScript will use a "component" from windows. It doesn't really matter what that object is, but if you are interested, just google it. To create this object, write this on the file:

countLOC.vbs (1):

Set fso = CreateObject("Scripting.FileSystemObject")

This will create a object named fso (short for file system object) which we'll use to access files and stuff. Let's say now that you want to open a file named "text.txt", which resides in "c:\data". All you have to do is:

countLOC.vbs (2):

Set fso = CreateObject("Scripting.FileSystemObject")
Set objTextFile = fso.OpenTextFile("c:\data\text.txt", 1)

This will give you access to the objTextFile, which you will use to manipulate the text file itself. Looking at the arguments (the stuff enclosed in parenthesis), you will notice a '1' being passed. This tells fso that the file is to be openend as read-only, preventing the script from messing up with your text. Now we need to count the lines from text.txt. We do that by reading until the end of the file and then checking how many lines were read:

countLOC.vbs (3):

Const ForReading = 1

Set fso = CreateObject("Scripting.FileSystemObject")
Set objTextFile = fso.OpenTextFile("c:\data\text.txt", ForReading)

objTextFile.ReadAll
Wscript.Echo(objTextFile.Line)

On the code above, we made two modifications. First, the number that tells fso that the file is for reading only was replaced by a constant, so that our code becomes more readable. Second, we read the whole file using the method ReadAll and then printed, through the use of Wscript.Echo, the number of the current line of the file. Since we read the whole file, the line printed will be the last one. The code above is the skeleton of what we will be using to create the report containing all the files number of line. The first difference is that we'll get a list of all the files in the folder and then we will analyzed each one of then. To do so, we will use interaction loops in our script. The second difference is that we will output the result to a file instead of pop-ups. It's easy but, if you are not really interested in learning the hows and whys, skip until the last code listing.

The way to retrieve the file listing from the folder is to use the method fso.GetFolder("folderPath"), which returns a folder object, and the use this object to retrieve the listing. We iterate through the listing by using For Each loop:

countLOC.vbs (4)

On Error Resume Next
Const ForReading = 1
Set fso = CreateObject("Scripting.FileSystemObject")
' Open an output file to write results. Existing files will be overwritten.
Set reportFile = fso.CreateTextFile("c:\FileList.txt", True)
' Get the file listing for the given folder
Set folder = fso.GetFolder("c:\data")
' iterate through the the files
For Each fileIdx In folder.Files
' Open the file using the name from folderIdx (folder index)
Set objTextFile = fso.OpenTextFile("c:\data\" & fileIdx.Name, ForReading)
objTextFile.ReadAll
' Output to the reportfile
reportFile.WriteLine(fileIdx.Name & ";" & objTextFile.Line)
Next
' Close the report file
reportFile.Close

As you can see, we made many modifications. Line 1 informs the script that, in case of an error during the For Each loop, it should resume on the next item. Line 6 creates the output file and line 9 creates a folder object that can be used to access the file listing. Line 12 begins the loop, which sets a variable fileIdx to each file in the folder. As you can see in lines 12 and 18, fileIdx.Name returns the name of the file.

This is the gist of it. The script access a folder, "c:\data", iterate through all files in this folder and outputs each file LOC to "c:\FileList.txt". But we want to make this into a real tool, right? So what's wrong? Well, the script need to be edited everytime you want to change the folder that contains the files or the name to the report. So let's parametize those:

countLOC.vbs (4)

On Error Resume Next
Const ForReading = 1
' Get first parameter as the foldername
sFolder = WScript.Arguments.Item(0)
' Second parameter is the report name
sReport = WScript.Arguments.Item(1)
If sFolder = "" Or sReport = "" Then
Wscript.Echo "Invalid Syntax. Expected: countLOC.vbs folderName reportName"
Wscript.Quit
End If
' Create a file system object that will help us acessing files
Set fso = CreateObject("Scripting.FileSystemObject")
' Open an output file to write results. Existing files will be overwritten.
Set reportFile = fso.CreateTextFile(sReport, True)
' Get the file listing for the given folder
Set folder = fso.GetFolder(sFolder)
' iterate through the the files
For Each fileIdx In folder.Files
' Open the file using the name from folderIdx (folder index)
Set objTextFile = fso.OpenTextFile(sFolder & "\" & fileIdx.Name, ForReading)
objTextFile.ReadAll
' Output to the reportfile
reportFile.WriteLine(fileIdx.Name & ";" & objTextFile.Line)
Next
' Close the report file
reportFile.Close

Lines 5 and 7 load the arguments from the command line. Lines 9 through 12 test to see if the parameters are passed correctly. To use the code above, you will have to open the command prompt (Start → Run, "cmd") and type

c:\>countLOC folder output

Where folder is the path of the folder that contains the files you want to analyze and output is the name of the report.

Now, a seasoned VBScript writer can re-adapt the code above and instead of using a ReadAll, read it line-by-line and check if the line is empty or not, if it's a comment or not, etc.

Presentation 1.0

2008-07-29T11:40:00.000-03:00

I must say that I've been stalling beginning this web site for a few months. Keeping a real web site or a blog up-to-date is a lot of work. You HAVE to post weekly or more, or the few visitors you get won't return.

Secondly, you have to work on a good layout. This means knowing a lot of HTML (which incidentally, I do), choosing the right place to host and have at your disposition a number of free hours which none of us, computer geeks, have. That is, unless we decide we can stop playing that addictive game every night -- a thing that probably won't happen.

Third, and most important of all, you have to choose subject(s) carefully. This is difficult. It's easy to stray from what you should be talking about (your blog presentation) and begin a discussion over what type of coffee you like or your favorite supermodel.

It's no supermodel, but is my favorite

So, what can a Blog be about that there aren't a hundred more in the Web? That is a impossible question, mostly because if there's a subject that no one has ever thought of doing a Blog over, it must be rare. So I've decided to improve over some blogs that already exist and hope that mine is Google listed (otherwise, nobody will ever find me out).

And I guess that will only happen after I have fifty posts or more, but still I'm going to try. So, to answer the question, what will this blog be about?

This blog will be a place where I'm going to post SOLUTIONS to everyday problems when using a computer. Those problems should be simple stuff that most people have to do everyday, like search for stuff on files, creating reports etc. Mainly, I'll be dealing with automation, by creating a number of MACROS or using scripts to solve stuff.

The target audience will be the not-so-common computer user: someone who knows what a Word macro is or has heard of Linux shell scripting. However, no prior knowledge over programming, scripting or macros will be necessary.

The blog won't be focused on tweaking or troubleshooting Windows, actual programming (even though some programming might surge as part of the solutions), or high-technology discussion (SOA, .Net or whatever). If it's not useful for a more common user, it won't be here.

But don't worry if you don't find what you want in this blog. I'm deadly sure there will be thousands other web sites with whatever you seek.