In a change of their current policy of providing filtered content in China, Google has decided to stand against the Chinese government and remove all filters on their search results. The reason mentioned for their policy change was a grave web-based attack against the accounts of human rights leaders.

I think that this is a honorable decision, and all free countries should support such an initiative that aims at making the web more democratic. After all, I think that if we can’t make the whole world a democratic place, we can at least try to do the right thing with use of technology.

See the full announcement in the Google blog.

Google wave was introduced in the last I/O conference (2009) by Google as  a new platform for communication. A platform using web 2.0 concepts, and providing an array of features that has not been available in other platforms.

I received an invitation to use Google wave and decided to take a quick look. Although some of the features of the product are impressive, there are more than a few that are annoying, so I don’t know if the future of this tool is so interesting anymore.

• Speed: I found the performance of Google wave to be less than desirable. Searches (especially for public documents) take a long time. Loading of documents also take a lot of time. Maybe this could be solved by showing only small parts of a wave instead of loading everything.
• Interface: the interface is unconventional. While one may get used to it after some time, it is difficult to new users to navigate. Compare this with a web site like twitter, that is easy for anyone to understand.
• Extensions: there is an extensions protocol that allow programmers to create new functionality. However, I found it hard to find information on how to use these extensions effectively. Even installing extensions is not so clear at the beginning.
• Compatibility: I expected that you could integrate Google wave seamlessly to Gmail and Gtalk at least. It doesn’t seem to be so. I am still trying to make this work.

It looks like Gwave would be interesting for a group of people that decided to collaborate on the platform. But I think that integrating email and other tools into Google wave is more complicated than it should be. Or maybe I just didn’t get it — but if that is the case there is a lot of people currently in this situation.

When working with Oracle databases, it is sometimes interesting to create a duplicate row of a table. Most of the times this happens when I am testing something on an application and need to tweak one of the entries in a table.

There is a standard SQL trick to duplicate elements of a table that can be used in an Oracle database. I am showing this here because it can be of interest for other people that have the experience of working in an Oracle environment.

The basic idea behind this technique is just to create a temporary table that will hold the data only during the time necessary to make the required modifications. Since the table is created immediately, the inserted content will make the table have all columns of the original table.

Suppose that the following returns non null:

select * from myTable where myKey=8572

Then the required code looks something like the following:

EXECUTE IMMEDIATE
CREATE TABLE temp_table AS SELECT * FROM myTable where myField=8572
UPDATE temp_table SET anotherField='AA'
INSERT INTO quote SELECT * FROM temp_table
DROP TABLE temp_table

With this simple trick one can duplicate any row and modify it to hold the required values.

Further Reading

A comprehensive book on Oracle is Oracle Essentials by Greenwald et al. Here is another Oracle book that is worth reading to get a better idea of how it works.

Since its release, Chrome has provided several ways to improve user experience on the web, including an easy-to-use interface, short start up times, and advanced features for developers.

One of the features that has made life even easier for users is the introduction of extensions to the platform. With extensions, Chrome is now able to add features that might be of interest to users, without requiring them to be programed by Google engineers. In fact, extensions will work without even requiring the browser to restart — a big advantage when compared to Firefox standard behavior.

An extension that was recently introduced allow users to have much easier access to PDF files. PDF is the standard format for files that need to be printed, and is used everywhere. However, viewing PDFs has always been less efficient than viewing HTML, because PDF files require an external plugin, such as Adobe Acrobat reader. Although the plugin is easy to use, it doesn’t behave exactly like the browser, which may be a disadvantage to many users.

A new Chrome extension has improved this situation. The Docs PDF/PowerPoint Viewer extension allows PDFs to be displayed in an HTML page, just like any other document. The service is provided by Google, and the result is very easy to use.

The main advantage of using this extension to Chrome is that it will open PDFs much faster than calling a PDF reader. Also, once the page is loaded, it can be easily manipulated as any other HTML page. It doesn’t behave as a separated application inside browser: it is just the browser natively displaying a document.

If you install this extension and want to get the real PDF (for archival reasons, for example), you can still save it to the hard drive. The process is the same as for other documents: right click on the link, and select the file name where Chrome will save the document. That is all you need to get a copy of the PDF on your computer.

One of the biggest issues in developing software is how to write programs that have robust design. Robust design, of course, can have different meanings, and won’t be the same thing for everyone. However, there is the intuitive notion that software that can withstand the test of time is based on robust design.

My experience in software development has shown that many of the common notions of robustness in software design are false. For example, the idea that software has to always be reusable is a major source of problems for software architects and developers. It is a fallacy that has been promoted by vendors of new technologies, and in some way continues to be accepted without criticism.

A Few Personal Guidelines

Here is a set of guidelines that I follow when writing software, and that have proven to be much more useful in generating programs of high quality.

Implement only what you need: one of the things I try to avoid is creating software that is more general than it needs to be. If you are trying to be ahead of the development curve, there is always the risk that you will be going in the wrong direction. This happens because we can rarely be sure of the future needs of your organization.

Avoid useless abstractions: this is related to the previous topic, but deserves to be treated separately. Abstractions are useful if they simplify the way a feature is implemented. However, some abstractions exist only to satisfy the needs of developers.

This happens a lot when people start to treat everything as a design pattern, for example. Clearly, even the simplest development problems can be solved with design patterns, but they don’t need to — specially if this is going to turn the program into something more complicated.

Make it easy to change your implementation: at the same time, implementations should be easy to change, or even swap completely, if possible. Big abstraction can make this task harder too, so you need to be aware of the repercussions of using a more complicated data structure.

Address the main issues, avoid what is non essential: one of the big laws of programming should be: avoid doing what you don’t need to. Many developers are tempted to add features that are non-essential, but “nice” to have. The problem with this line of thinking is that nice features also takes time to test and maintain. Testing and maintenance are the biggest costs in software development, not the initial time spent on developing the feature. Anything that we can do to reduce testing and maintenance is useful, specially if we are still meeting the requirements of the project.

Avoid using components that will require effort to understand/change: Finally, although it goes contrary to the wisdom of most project managers, there are cases in which you don’t want to use a component for a project — even if it already exists. Some components are not written to be reused, and trying to do so only make the project more difficult to manage. If that is the case, don’t try to reuse for the sake of it — it is just a pointless exercise if it is not improving the productivity of the team.

Further Reading

A book that explores many of these topics (presenting real numbers) is Facts and Fallacies of Software Engineering, by Robert L. Glass.