Freedom Inc.

Why I love PostgreSQL

2011-03-04T09:38:00.000-08:00

What if you have a "users" table, and all the properties for the users are in the "property" table. Would a select like this be efficient in PosgreSQL?

select distinct u.*, p3.value
from users u
join property p1 on u.id = p1.user_id
join property p2 on u.id = p2.user_id
join property p3 on u.id = p3.user_id
where p1.name = 'admin' and p1.value='false'
and p2.name = 'email' and p2.value like '%mah%'
and p3.name = 'name'
order by p3.value;

Surprisingly this is quite OK, since PostgreSQL won't be stupid enough to do the full Cartesian product.

I love you PosgreSQL.

Oracle repents.

2011-02-07T03:08:00.000-08:00

Oooooo. Just watch the progress.

Before...

... and after ...

Still from here.

Nice one Oracle.

Java Developers - The bums of the software community at Oracle

2010-09-09T05:42:00.000-07:00

They can't even afford a shirt like sysadmins and non-java developers.

From here.

Struts2 Best Practices

2010-04-19T12:27:00.000-07:00

After reading Struts 2 in Action (a definite read for people who have no experience at all using struts 2), and after finishing a project and actually delivering it to the customer, and in the middle of the second one, I've decided to write down the best practices that I follow.

The reason why i'm writing this is that I couldn't find real case examples of good patterns to follow in developing a struts2 application, even the best practices from that book are quite slim, and I'm not going to reiterate them here.

Tooling

Buy IntelliJ Idea. I have no words to describe how much more advanced is this compared to eclipse. Jump to definitions of actions, jump to implementing classes, you can pick what action you want to go to from a class (if multiple actions are mapped to the same class), etc. Simply outstanding.

Buy JRebel if you have I18N in your application. Although they brag to have struts2 support I couldn't make it work (even if conforming to their website should be "brainless" to do it). What it does well though is reloading of classes (like adding methods and co.) and bundle reloading.

Programming Style

Don't write any code until you fully understand the ActionContext and the ValueStack, and how the property resolving takes place. Otherwise all the iterators and push constructs in the JSP will simply look like voodoo (I am talking from experience here).

Write tests for your actions. It does seem a bit hard, but it is actually quite simple. Just add this dependency in your maven2 pom.xml file, and just create tests:

<dependency>
  <groupId>org.apache.struts</groupId>
  <artifactId>struts2-junit-plugin</artifactId>
  <version>2.1.8.1</version>
</dependency>

Don't create actions with multiple methods. "execute" and the operation you want to execute (e.g. "createUser") should be enough. Execute would be used for rendering a jsp/ftl/vtl template, and the action will be used to actually do your business requirement.

All your validations, try to express them via annotations on the business method (@Validations), and if you can't since they're to complex, and expressions won't cut it, simply implement the validate() action. Never put validations in the model (if you're using ModelDriven actions).
The reason is that you always have to check two files in order to see if the business method will be called.
Another thing to keep in mind is if you use annotations AND multiple methods, struts 2 for some reasons collects all the annotations from all the methods and applies them against the current method being called. (as of 2.1.8.1)

Use only one I18N package.properties file for the whole project. If the project gets big it's hard to track which key is where and you'll end up with lots of duplicate keys, and the fear of deleting the keys since you don't know who uses them will be there constantly; unless you're doing some funky searches against the package name in the java sources, and in the struts.xml config files.

Not fun at all.

Preffer interceptors over servlet filters. The only reason why you would want servlet filters is to intercept resources that are not actions. Otherwise the access to the ActionContext is invaluable. Both of them are fairly lightweight so I see no reason in having things that do the same thing in two places (web.xml and struts.xml).

Create interceptors to inject services for you (like EJBs, or whatever counterparts are in spring). Your methods in the action should become simple wrappers over the actual business services. Also it becomes trivial to test, since the tests will also simply inject mocks of the actual services.
Don't be afraid to create custom interceptors for whatever you need them. They are extremely lightweight

A "full" action implementation would be along these lines, so it is imediatelly clear what it does, what validations does it require, and is trivial to test:

public class RegisterUserAction extends ActionSupport {
    // ...

    private String username; // + getter/setter

    @EJB
    private UserService userService; // no getter/setter, set by interceptor

    public void validate() {
        // custom complex validations
    }

    @Validations(
        // ... most of the time validate() is not needed.
    )
    public String registerUser() {
        try {
            userService.registerUser(username);
        } catch (Exception e) {
            LOG.error(e, e);
            addFieldError("some_field", getText("some_specific_error_key");
            return INPUT;
        }
        return SUCCESS;
    }

    // execute is mapped as excluded in struts.xml for validations
    public String execute() {
        return SUCCESS;
    }

    // ...
}

That would be it. As usual, I'm extremely interested in your feedback.

Have fun programming with struts 2.

MagicGroup 1.3.0 is out

2010-03-06T15:12:00.000-08:00

Hi, for all of you tracking MagicGroup, version 1.3.0 is out.

It features a number of bugfixes (like when having a file with the same time multiple times in a group and deleting it, or a NPE that happened once in a blue moon), but most important it adds descriptions to the files.

Thus you can click now on a file/group, and then press the pencil button and edit the descriptions for the item. The short description is appended to the file name in the tree view, the long description is visible in a tool tip on mouse over over the file/group.

I needed it since I had a maven2 project and all my files were pom.xml, pom.xml, etc :) for all the project. Not very helpful as you can imagine.

As usual, you can download it from here:
https://sourceforge.net/projects/magicgroup/

and sources (mercurial repository) here:
http://magicgroup.hg.sourceforge.net:8000/hgroot/magicgroup/magicgroup

My ISP is really cool

2010-03-05T10:28:00.000-08:00

Your average video speed at this location from February 04, 2010 to March 04, 2010 was 10.85 Mbps.

Pretty much ownage.

MagicGroup 1.2.1 released today.

2010-02-28T15:42:00.000-08:00

It is with great joy, that I announce the release of version 1.2.1 of MagicGroup, available at:
https://sourceforge.net/projects/magicgroup/files/

MagicGroup is an eclipse plugin that facilitates the organisation of files in a logical structure, not bounded by the file system structure, especially useful when learning frameworks.

Change log:
* Saving groups take place now in the workspace folder, instead of the eclipse project folder.
* Accessing of the files takes place via the portable path instead of absolute path, thus some issues when opening files (synchronisation with projects, autocomplete) should be fixed.

You can checkout the source from here (mercurial):
http://magicgroup.hg.sourceforge.net:8000/hgroot/magicgroup/magicgroup

KDE network manager mockup

2010-02-22T21:47:00.000-08:00

As you might know, the "JavaScript Jam Sessions" contest is on the way, at plasma.kde.org. Since I've realized that I don't have enough time or energy to implement it, but I would love to see it in the KDE desktop, I've decided to release the design for public use.

If it's going to be done in javascript or python, I would love to take a look and help (even if the entry will be used for the contest, I have no interest in the prizes).

The idea as you can see is to display the wireless networks in a more accessible way, sorted by signal strength. Eventual metadata about them (encryption mostly) can be presented as the small black pills on top of the icon.

Connections to the wireless network should be presented dotted, the ones to the wired lines as a straight line (you can see that we have a connection to a wireless access point).

If the Internet is accessible the blue globe from the top right should be blue, otherwise it should be grayed out.

Here is my kde-look entry.

You can download the full XCF (gimp) file from here.

Drowning in Struts2

2010-01-20T08:39:00.000-08:00

We are building a Struts2 application. Yay!
We are building a Struts 2 component. Yay!
We're going to use several programming languages for that. Yay! Wait, what?!

Here is a tiny snippet from a much larger (and cryptic looking code calendar component) we had to develop:

 1 <td class="dateDMHM">
 2     <@s.textfield id="${parameters.name}.hour"
 3         name="${parameters.name}.hour"
 4         onfocus="if(this.value=='hh')this.value=''"
 5         onblur="if(this.value=='')this.value='hh'"
 6         onchange="setChecked('true', '${parameters.id}_true')"/>          
 7 </td>
 8 <td class="dateText">.</td>
 9 <td class="dateDMHM">
10     <@s.textfield id="${parameters.name}.minute"
11         name="${parameters.name}.minute"
12         onfocus="if(this.value=='mm')this.value=''"
13         onblur="if(this.value=='')this.value='mm'"
14         onchange="setChecked('true', '${parameters.id}_true')"/>
15 </td>

Can you tell how many languages are being used in this freemarker (1) from a Struts2 application snippet of code?
td - plain HTML (2)
class="dateDMHM" - with CSS (3)
@s.textfield - struts2 tags (4) available in the freemarker, offered transparently by struts2 engine
onfocus="..." - JavaScript (5)

even if it looks innocent, that id="${parameters.name}.minute" is actually an OGNL expression (6).

This component is being used as a result in a JSP file (7) from an action implemented in Java (8).

Even if we can say that we can ignore HTML, CSS and JavaScript since they are ubiquitous, we still have 5 languages to master in order to build one application.

Compare this with a normal JSF (+xhtml) stack that brings you 2 new languages: JSF and Java.

Don't get me wrong I do believe that struts2 is a decent framework, but in the languages area I think it's a bit too much.

Note: I could say 3 languages on JSF's part: JSF, Java and EL, but I would have to add EL as also being available in JSP, thus 9 languages for the Struts2.
Note 2: I know we can completely remove JSP from the picture, and use freemarker templates directly, but I doubt that would be a "normal" Struts2 application stack.

Bring 'em hell!

2010-01-17T15:14:00.000-08:00

Do you remember when google said they will pack their toys and leave since China hacked into some human right activists accounts?

The cool part is that initially China wanted to play down the move from google, saying that they (google) broke the law, thus they can leave, BUT the rest of the economic environment should have no fears, since China is not going to disrupt their business.

IMHO Google played China like a violin pretty much saying, "You don't care what we're going to do? Then you shall kick us out.", and started giving results uncensored.

I find this brilliant since now China is in a no win situation. They can let google operate uncensored, but this goes against their policy, or they can kick google out, but I bet in that very moment all the Asian stocks will sink, since now China contradicts itself as not disrupting business and offering guarantees of a stable market environment.

With the US government backing google it's a hell ride for China.

And I love it.

Why? Because google said implicitly this to me, and all others who have e-mails on google: "If any entity will try to use your private e-mails hosted on our servers against you, and against your will, we will bring them hell".

Thank you google!

And for all the people still using Internet Explorer out there, I hope one day you'll learn your lesson.

Low level vs high level tools

2009-11-30T02:20:00.000-08:00

ComputerWorld posted a "debate" using high level tools (like integrated tools as Visual Studio) against basic ones (a basic text editor, command line compilers). The original article is here.

I think that many persons talk to promote the products they're working on: is natural for a shell creator to encourage all people to use "basic stuff", as a C++/CLI creator will want people to write more in C++ as this is his/hers language, and not in C# (it's closest competitor). They use arguments like "abstraction penalty" as an argument for their tools working faster, since they aren't doing indirected calls and use (more directly) components without their associated cost.

I will take one at a time:

using text editor/command line compiler against using a high level IDE. The reason I would firstly use an IDE is that it organizes and simplifies most operations. Even if I will have to learn some operations that the IDE supports, like Refactorings (which are not a part of the text editors at all) which do permit you to reorganize your code, on the long run many faults such as misspellings are not done just because the IDE helps you write your code right. Exposing too much information might be tricky, but I think it's rarely shown to be as a big issue as to forgot to add a file into SVN. From this regard, in general the IDE makes me think on problem itself, not on spelling and how to put all the compiler arguments right. For example Eclipse has many perspectives, each with its own tools being shown, directed at an angle in which you want to see your problem from. If you just need to change a line, probably VIM is a much better option, but sticking to Eclipse it will fix your Java deployment into jars, will integrate with your SVN/Mercurial/etc. local changes, and you will not need to put on sticky notes all arguments that you've missed, and thus needed to recompile.
Managed code also lets developers "perform above their level of competence," This is really tricky if you don't know what managed code is in detail. You can translate this statement as: a virtual machine doesn't let you express at your level of competence, since most of the constructions that you normally would create are already there. Many design decision, that a virtual machine has implemented, are to prevent anti-patterns and to force developers to stay in the VM's sandbox. To put this in a UNIX perspective, the problem is like: the limited user will not let you express yourself since you are not administrator/root. But as administrator/root you can break your system, and there is a high risk that the problems you will encounter or create will have a greater damage, for no real benefit. Yes there might be leaks inside VMs but in the most cases they aren't. So you can simply work with your preferred VM code in Java/C# and at the end of the day the quantity of your issues that you'll find will be smaller
Abstraction penalty will make the trend: people will go to low level languages which do bring performance for future. The problem with JIT in particulars and their lack of speed is simple: the JITs are actually fast enough. Probably a JIT means at most to cut the speed in two compared with C++. In fact Java with Java 7 will improve once again performance of their running bytecode. This will mean a lot of applications will run just fast enough. Also, most applications are not games nor renderers. As for me, I am sure that Windows Vista/Windows 7 could be written as shell parts in .NET. The biggest proof is Paint.NET and the Linux's Mono application set. I am agreeing with the abstraction payment as long as you really depend on them (for example, please don't garbage collect while you're running my pacemaker. Thank you). But in fact being inside a VM will only mean to you that your runtime environment will be much easier to be fixed and upgraded, and your code will be much easily run on any platform that supports your VM.

The point I wanna make is just this: for many mediocre programmers, writing yet another algorithm using low level things is unlikely, and in most cases will not run as fast as the as the same C#/Java code on the long run. Even when you will write everything perfectly, a new version of your virtual machine will get the code so close to your hard optimized code that will make all the extra effort worthless. Using IDEs will simply make your working procedure simpler.

So, why use notepad when you have Eclipse?

Internet-Enabled Devices in Microsoft's Vision

2009-11-18T08:46:00.000-08:00

I can't make this kind of stuff up. This is an actual opensource release from Microsoft:

"Microsoft has released part of its .NET Framework - the part for internet-connected smart devices - into the open-source community. [...] But don't get too excited. You won't be getting the full .NET Micro Framework stack, as Microsoft's open-source code donation will lack the TCP/IP stack and cryptography libraries."

So let's recap: .NET for "Internet-enabled smart devices" with no TCP/IP nor security?! Wow! I'm really impressed.

What's next, really? Because this one definitely blew my mind.

The full article is here.

DroidCan't

2009-11-12T07:26:00.000-08:00

I had the opportunity to see the commercials from Motorola with iDon't. While I found it cool to slander the iPhone platform (Mac vs PC anyone?) I've started receiving lately some bad reviews for my application from some droid users.

Ok, I had bad reviews even before, no biggie, but these ones were like: "it doesn't work on Droid". Thus I started tracking one guy who gave AndroidKnight one star, and here is a screenshot with what other applications he gave bad ratings:

Wow... dedicated guy.

See a pattern? All of them are 3D applications, and this disgruntled user managed to give 5 stars to an application which wasn't 3D. (To be honest, I would be also filled with rage after paying more than 500 bucks to find out that no OpenGL application works).

Thus I thought "dude, that must be some mistake Motorola did, probably some weird API they've added, but I'll just download their SDK, do a trick or two, and it would be up and running in no time". Turns out I was wrong. There is no customization in the software that Motorola provided with their phone.

As Graig Wilson (from Motorola) said it in plain English:

You already have it, if you have the new Google 2.0 SDK. Droid has no "Moto customizations"; the software on the shipping device is the Android 2.0 platform, straight from Google. So the emulator that Google provides really is the emulator for the shipping device.

Well guess what: AndroidKnight (and I am willing to bet every other 3D application from that list) works under the emulator. For 2.0, of course.

It's a bit frustrating knowing that just disabling the hardware acceleration on Droid would probably "fix" it.

So this brings me to this very simple point: I don't know if it is the fault of Google or Motorola. (I've heard Galaxy from Samsung has the same issues, so I tend to believe it's Google).

To be honest I don't really care that much.

But think for a minute or two, what does it matter if you have some "cool" phone which doesn't do some basic stuff that it is supposed to do. Because the iPhone wasn't designed to have a real keyboard/run multiple apps/run widgets/etc. No one sells iPhones for that, they sell it with just one saying: "it just works".

Ok, enough ranting, what is my proposed solution?

Make google enforce a suite of tests that every phone should pass before it can be named android compatible. If they don't pass the tests, they shouldn't be allowed to run an operating system named android (enforce the trademark), but rather they should be forced to rename their operating system (so they can still use the same sources if they want).

Otherwise it will simply be DroidCan't too.

Update
Turns out that other people had issues as well and tried to figure them out. Please read that link since it might give insightful information on what you need to do next.

This read might also help.

At the moment I'm trying to change the initialization code to look more like here.

Update 2
This code works for RED = 5, GREEN = 6, BLUE = 5, ALPHA = 0, DEPTH = 16 and STENCIL = 8. Note that in my code DEPTH is the minimal DEPTH, but I will give better distances if the DEPTH is actually higher that the DEPTH value.

    private EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
            EGLConfig[] configs) {
        EGLConfig closestConfig = null;
        double closestDistance = 1000.0;
        int idx = 0;
        for(EGLConfig config : configs) {
            idx++;
            int r = findConfigAttrib(egl, display, config, EGL10.EGL_RED_SIZE, 0);
            int g = findConfigAttrib(egl, display, config, EGL10.EGL_GREEN_SIZE, 0);
            int b = findConfigAttrib(egl, display, config, EGL10.EGL_BLUE_SIZE, 0);
            int a = findConfigAttrib(egl, display, config, EGL10.EGL_ALPHA_SIZE, 0);
            int d = findConfigAttrib(egl, display, config, EGL10.EGL_DEPTH_SIZE, 0);
            int s = findConfigAttrib(egl, display, config, EGL10.EGL_STENCIL_SIZE, 0);
            int configCaveat = findConfigAttrib(egl, display, config, EGL10.EGL_CONFIG_CAVEAT, EGL10.EGL_NONE);
            
            double distance = Math.sqrt( Math.abs(r - RED) )
                + Math.sqrt( Math.abs(g - GREEN) )
                + Math.sqrt( Math.abs(b - BLUE) )
                + Math.sqrt( Math.abs(a - ALPHA) )
                + Math.sqrt( Math.abs(s - STENCIL) )
                + Math.sqrt( 128 - d ); // prefer bigger depths if available

            Log.d("AndroidKnight", configToString(config) + "\n distance: " + distance);
            
            if (d < DEPTH && configCaveat != EGL10.EGL_NONE) {
                Log.d("AndroidKnight", "Ignoring config " + idx + " since config caveat is : " + configCaveat + " and depth is " + d);
                continue;
            }
            
            if (distance < closestDistance) {
                closestDistance = distance;
                closestConfig = config;
            }
        }

        Log.d("AndroidKnight", "Selected configuration: " + configToString(closestConfig));
        
        return closestConfig;
    }

Explanations:

I'm using sqrt, so changes in color bits will have a bigger impact. For example if no configuration matched and simply summing absolute of differences, a target configuration like R:5,G:6,B:5,A:0,S:0,D:16 would yield the same distances for these configurations R:5,G:6,B:5,A:0,S:8,D:16 vs R:8,G:8,B:8,A:0,S:0,D:16 if I would just sum up values. The idea is that I would rather have the bytes per pixels right, than the stencil buffer right from these configurations; especially since it seems its a bpp issue in the first place.

I don't care about the depth as long it is at least the depth required. I actually prefer bigger depths if available.

I don't want any configuration that is not conforming or slow, etc. This is why there is a flag checking. I didn't even knew about it before my saga.

The reason why stencil is set to 8 (even if I'm not using it) is because it fails to initialize if it is 0 - I might have done something wrong.

Feel free to use this code as you like.

I give you the newest Windows7 (KDE 4)

2009-10-23T14:57:00.000-07:00

ZDNet Australia installed in a shop KDE 4, and told people that this is the new Windows7. They presented applications such as amarok, dolhpin, and openoffice.

See what happened next at this link.

It is priceless. I don't want to be mean, but din't I told you so? Watch the people's reactions and how they describe it and relate to Vista.

It is simply unbelievable.

KDE really made a great product.

Windows 7 vs. Mac Snow Leopard: The Great Debate (translated)

2009-10-19T15:57:00.000-07:00

The following content is a parody. It is made after this interview so it would make sense to read that one first. By any means this is not what Brian Coll nor Jay Paulus would have said, but what I in my artistic rambling invented as answers to the questions put by Lance Ulanoff of pcmag.com.

This is for entertainment only and I am not claiming to be factually accurate.

Lance Ulanoff (Question):

Let's start with 64-bit. For perhaps the first time in operating system history, average consumers are aware of the 64-bit choice and thinking about whether or not they need or want to use it. What does Apple and Microsoft bring to the table here?

Brian Coll (Apple): Well, we have this cool kernel that we taken from BSD, and we are based on a cross-platform UNIX. Not to mention our hardware pool it is quite small, and also we have our own packaging system. To migrate to 64 bit was quite painless. We did a great job about it, so we decided in the end to disable it by default.

Jay Paulus (Microsoft): We have two versions. D**n these years of compatibility to keep, they really choke us. And unlike Macs we give our customers options: The option, of reinstalling your Windows and all your other applications whenever you want to switch to 32bit to 64bit and back, is always on the table. We want people to have the chance to install Windows as many times as they want. This is what we call customer choice.

Lance Ulanoff (Question):

Modern computers now feature multicore CPUs. However, consumers aren't always sure if their operating systems or apps are taking full—or any—advantage of all those cores. What are you guys doing in the multicore space?

Brian Coll (Apple): You had to ask this, didn't you? To answer your question though, we provided an API so that the kernel can do threads instead of the developer. It's fantastic, I've heard about it yesterday from Steve, he was realy enthusiastic also. We suport one platform since we all know that cool people use one platform (namely Mac + iTunes).

Jay Paulus (Microsoft): Thank you for the question. Here we feel we've outdone ourselves: Not only that we have this very cool and technologically advanced hybrid-kernel that works on several platforms, including 64 bit, but we've traded a bit of security over here, a bit of performance and resource usage over there and in the end we got Vista which is perfect on the upgrade path to a much needed new PC and new hardware. And you can still get viruses.

Lance Ulanoff (Question):

Okay, let's step out from under the hood and talk about what consumers see on their desktops, specifically, the UI?

Brian Coll (Apple): Well, our customers are licking their screens since 2002. I think that said it right there. But still, if you want me to continue, dock is simply cool, we have cool effects that actually help you, we have Cover Flow to search for stuff and Time Machine which is integrated with your desktop seamlessly. And we know cool people use iTunes. You can even see the contents of the documents in the finder even if you can't possibly do anything with that file since you don't have an application installed to process it. Isn't that amazing? And we didn't yet found a way to convince game developers to consider our platform.

Jay Paulus (Microsoft): I think no company had the pressure that Microsoft had. We've tried to copy Apple since day one. Bill was telling me that the first day he listened to Steve Jobs, he has figured out on his own that the GUI is the future - without any Apple inspiration. So as I've said, we've tried to copy Apple but they are moving so d**n fast. They've added attachments, we copied attachments, by the time we finished they had multitasking, we copied multitasking, they had at that point skinable interfaces, we copied that, they came up with the finder, we finally done that and they have the time machine and the cover thingie? When is this going to end? This is getting ridiculous. We still have dlls, defragmentation and registries to fix, give us a break. As I've said, the pressure is fantastic.

Lance Ulanoff (Question):

Okay, let's talk about backup—something everybody needs, but no one really does. Windows Backup has been around for a long time, but isn't widely used. Apple's Time Machine arrived with Leopard and deep integration with the hardware. Where are we now with OS-based backup?

Brian Coll (Apple): Well thank you, thank you, thank you. Finally some justice! We have this really cool backup system. Is freakin amazing. You can literally destroy your Mac with a hammer after a backup, and then restore your backup on your brand new expensive Mac. Your data is there, your applications are there, you can do only partial backups, this is just cool. Neither me nor Steve don't know how is this done, but it is really cool.

Jay Paulus (Microsoft): Ok.... so.... Let me think a few seconds. (5 minutes later) Anyway, we have this program which is really awkward to use but we use it for marketing; it is named Previous Versions. You can still loose all your data, if your hard drive crashes, so yeah, it's pretty pointless but have no fear, you can allways use one of your 32bit or 64bit media that comes with the package to reinstall Windows and all your applications. You don't need to pay anything more, just reactivate Windows again after installation. This is what we call easy and painless. Or you can backup everything and in a matter of a few hours you can have your data stored in an external hard drive.

Lance Ulanoff (Question):

Perhaps one of the most stressful things users face is the act of upgrading their OS. With Windows 7 coming out, people will be making choices and possibly upgrading their OS. Mr. Croll, what's Apple's perspective on what's happening with Windows 7?

Brian Coll (Apple): Microsoft wants to milk their users of some serious cash. They've been drying for a few years now.

Lance Ulanoff (Question):

Jay?

Jay Paulus (Microsoft): Well, it took us eight years to come up with this stuff and tadaa... people don't want to buy it. This... this, is unacceptable man.

Lance Ulanoff (Question):

After years of integrating utilities and even full-blown apps from competing products in the operating system, or as part of the OS package, Microsoft made an about face this year and is letting end users decide whether or not they want to download Mail, Messenger, Movie Maker and other apps. Why?

Jay Paulus (Microsoft): This is the reason I don't travel to Europe. Ever. EU keeps freakin sueing us, saying we're a monopoly and this and that. How would you feel paying 1.4 billion dollars to EU? I thought so. We neither. It's already hard keeping up with Apple, Linux and all the stuff that they do, but multiple competitors? Come on, this is simply unfair. And Vista didn't really sold.

Lance Ulanoff (Question):

Brian how do you view the debundling of applications?

Brian Coll (Apple): Thank God EU is not on us on this one. We already have a lot of heat on the iPod-iTunes thinge. And I can say without a doubt that what Vista's approach of debundling applications is plain stupid. I don't get why they don't keep paying 2 million euros per day like they did before.

Lance Ulanoff (Question):

In the race to build the best operating system, where do each of you think you stand? What sets you apart?

Brian Coll (Apple): Well a thing I can say for sure that we really don't have games. One or two titles, but that's pretty much it. On the other hand we don't have Registry, DLLs, activation, defragmentation, viruses, etc. Another thing is that we tried and failed several times to enter the server market.

Jay Paulus (Microsoft): So what? We have registries, we have DLLs, and so what? We know they suck, but do you really had to bring them up? And let's not forget we also have this Previous Versions software where you can backup your DLLs, so it's not DLL Hell (TM) anymore; we improved this by a factor of ten so we name it DLL Hell XP (TM). XP is from eXPerience since we have over 15 years of DLLs and registries experience. And let's not forget, we don't talk about it. Very important. Plus we all know Apple is way too expensive. If I want a toaster I buy a toaster not a Ferarri that can also toast bread.

Lance Ulanoff (Question):

What about Mr. Croll's activation and technology comments?

Jay Paulus (Microsoft): Ups, it seems I've skipped this one, heh heh... We use the activation mechanism to be sure you don't have a pirated copy of Windows, or you upgrade your computer or components from it, without buying a new Windows license.

Lance Ulanoff (Question):

Let's talk about pricing. There are free operating systems out there, like Linux, but, as we can see from market share, free does not necessarily translate into mass-market adoption. How do the two of you see price and the OS?

Brian Coll (Apple): Well we believe in charging the user as much as we can. A new keyboard? 50 euros, an upgrade? 25 euros. I really think we've nailed down quite well.

Jay Paulus (Microsoft): In contrast to Apple, we believe in charging the user as much as we can. You will pay 200 bucks for your bare windows, and then you need to buy an antivirus, a video editor and so on. You can either buy our software or buy directly a computer from the "mini" series with XP installed on it in the same price range.

Lance Ulanoff (Question):

Okay, here's your opportunity to make your case for your OS. Mr. Paulus, why Windows?

Jay Paulus (Microsoft): Well we're changing the game since XP has launched. Every seven years or so we release a game changer version that offers our latest additions to keep up with Macs. And since Macs are simple, Windows 7 was also designed to be simple. So if it would be for me to sum it up in only one word, that would be it: Game Changer.

Lance Ulanoff (Question):

Brian?

Brian Coll (Apple): We've bundled more applications, and we've tied it with the iPhone since we want the industry to move forward. We've decided to do tiny upgrades and rebrand them with flashy names and tax them with flashy prices. If you look at what version we had ten years behind you will see real improvements and the thousand dollars price tags worth it.

Lance Ulanoff:

Thanks for your time guys, and have fun in the future.

Why in The End All Software Will Be Opensource, and Eventually GPL.

2009-10-19T04:47:00.000-07:00

On 16th of March, 1953 a man was born that was going to change the software industry as we know it: his name was Richard Stallman and he is the creator of the GNU operating system. He envisioned that software should not be necessarily free of charge, but free to change, and distribute the changes, while enforcing these rules downstream so no one could block the availability of sources and the possibility of changing them.

What few people know is that opensource existed long before - long in computer time - by the time Stallman decided in 1983 to start building his own operating system, Berkeley University has built and was distributing its own operating system called BSD since 1977.

Stallman believed that the approach BSD was taking was a faulty one, since it allowed other vendors to simply change and repackage BSD, without giving the rights to change it further down the line.

Fast forward through time, in 1990s the Free Software Foundation (FSF, the foundation that Stallman created in order to achieve the goal of a free operating system) was pretty much stuck in trying to develop a very advanced from an architectural point of view kernel. Here is where Linus Torvalds jumped in and developed his own kernel, less advanced at that point, but it worked.

Fast forward even more, the GNU operating system with the Linux kernel (GNU/Linux) became widely used for servers since it was way cheaper than its UNIXes counterparts. Even more forwarding, and Linux enters also the desktop market, and while initially looking horrible, managed to compete and even bypass other graphical user interfaces (GUI).

Current State of Software
Several companies learned from the momentum that GPL has created. Among them RedHat, SuSE (later bought by Novell), and later Ubuntu, and more important IBM and Google.

But their motives are not similar at all as the ones of Stallman. Truth be told, no money making company believes in being altruistic at all, everything is measured in a cost/benefit analisys - this is why Microsoft until recent years had no connection with the opensource world at all, and even now they have a double personality (also known as schizophrenia) when it comes to free/opensource software. Yes, they don't believe in being altruistic even if they say so.

Most companies know that the biggest expenses come not from writing the software - writing the software is actually cheap, but from testing it, and patching it. Thus it is cheaper for them to release the software opensource, even if some of the people will use it for free, since these guys will also test their product and do bug fixes for them.

GPL/opensource has these major advantages over the closed source software:

As a last resort, if the company that developed your software dies you can use the source (Luke).

You can create an ecosystem around your software platform that will drive to you customers, and it will be used as means of promoting your product.

You can start challenge the big ones - examples here abound: RedHat with their server families, Ubuntu with their desktop platform, Google with Android phones, the now defunct MySQL with their database, IBM with Eclipse, etc. etc.

You can cut down the costs by using software for free (as in also gratis) - full software stacks being available LAMP (Linux, Apache, MySQL, PHP), many JEE solutions, file servers, desktops, etc.

This changed the game of software development quite a bit. The competition went through the roof, and pushed technological advancements in areas where the closed source was the only established answer.

One last notable example is the example of Microsoft for which it took 7 years (some might say even more since Vista it's quite crappy) to release an upgrade from their XP line of desktops to Vista. Even Microsoft is slowly moving to opensource by creating its own license which is actually OSI approved.

Canonical with their Ubuntu promise made an interesting call by deciding to respect all the freedoms of the users. Their surge in adoption I think it reflects exactly that, since this is what I call being Customer Centered - (customer centered it's a fancy term that major corporations use in order to show that they care mostly about their clients).

Conclusion
Of course, you can disagree with me, and of course I'm biased. In this article I just tried to show a quick history on how GPL and GNU changed the face of software. And I'm going to leave you with these screenshots over time of various operating systems to let you decide who do you think innovated most and was most consistent in improving their software over time:

A Little Bit of History

1992-1993

Linux

No desktop version available (except maybe some very ugly ones).

Windows 3.1

NeXT (Apple)

1995-1996

Linux (KDE 1.0)

Windows (Windows 95)

Apple

Nothing new.

2001-2002

Linux (KDE 2.0)

Windows (XP)

Apple (Leopard is out: Roarrr)

2005

Linux (KDE 3.0)

Windows

Nothing new for the next few years.

Apple

Nothing new.

2009 (today)

Linux (KDE 4.0)

Windows (Vista)

Apple (Snow Leopard)

Windows is HOT.

2009-10-06T17:22:00.001-07:00

Who said that windows is lame?

Windows can be really hot:

Of course, this is KDE 4.3 with some plasmoids running on top of a Windows XP.

All that it remains is for Windows to fully change its shell and taskbar with the KDE one, so at least it might look like a decent operating system - for now we'll ignore what's under the hood.

KDE 4.3 team, you've outdone yourself. Great job!

AndroidKnight Presentation Video

2009-09-04T07:39:00.000-07:00

In these two videos I'm explaining some functional design decisions that were made when developing AndroidKnight, and what makes AndroidKnight one of the best chess games you'll find on a mobile phone.

I want to apologize for the video quality, but since this is my first video online, I know you'll be forgiving.

Part 1

Part 2

No need to wait. AndroidKnight is there.

2009-09-02T18:32:00.000-07:00

Hi, I can finally say it:

"It is done"

Version 1.0.3 of my AndroidKnight (written actually as):

Android

Knight

is finally finished and published on the Android Market. This is my entry for the adc2 (Android Developer Contest 2).

It's website is of course androidknight.com.

You may ask: where are the sources? Don't worry, they're arriving. And they will be GPL3.

Some screenshots to get you going:

Linux FTW

2009-07-10T07:06:00.000-07:00

I can not imagine doing development without Linux.

I don't get how people can live without multiple desktops (even on multiple screens they are a must), without a decent terminal (tabs and bash), or a decent window manager (at least expose, and "allways on top" for a certain window).

And here comes the fun part: I am in a Microsoft Gold certified company. I am using of course Linux (Ubuntu). Our customer uses RedHat Linux, and a JEE stack (JBoss). At home I have another Ubuntu box.

Recently I've bought a g1 (google Android), and now my phone also runs Linux.

Or as Mahatma Ghandi used to say: "And then you win".

Thank you Stallman.

svn real revert

2009-05-22T00:28:00.000-07:00

Sometimes it happens that we screw up our code in some file. And we want to go to some previous version of that specific file, hoping in our blind faith in source control versioning.

I don't know how many of you are still using SVN, and not Mercurial. If you do use SVN, you most likely have been fooled at least once by:

svn update -r oldrev path/to/file/to/change

The problem with this is that when you do update to a revision that is from the past, SVN still remember this, and on the next update && commit combo, you will yet again have the newer version of the file.

Thus a better way would be to just reapply the changes, but in the opposite order, without SVNs intervention. What we need is to create a patch from the new version back to the old version, and apply that one to the file.

What many people might not know, is that SVN actually knows how to do create patches between any revisions (not only in ascending way - e.g. from the oldrev to the newrev) including from a newer version to an older one.

So I will ask SVN to do a patch from the new revision to the old revision, and I will apply it directly using the patch command like so:

svn diff -r newrev:oldrev path/to/file/to/change | patch -p1

And by this, we do have the guarantee that only the changes are set into the file, without SVN changing the version of the file.

Update
Looks like the best way to do this, is to use svn merge, which will do also the patching, so the need for the patch command is unnecessary.

svn merge -r HEAD:oldrev path/to/file

Thank you rpetre.

Test Driven Development, How To?

2009-04-25T18:46:00.000-07:00

In software there are a lot of methodologies on how to implement software, but really few reduce greatly the time of development or really simplify it.

Most programmers probably know, but even if you don't know, it is good to notice: the great bulk of time in development of a software is spent in bug fixing and maintainance. They can take from 55% in most lucky projects, to around 95%.

The time spent in bug fixing relies mostly on how much you decide to invest in it also. For example having 95% of time used on bug-fixing could mean that the software product emphasizes a great level of quality. For this scenario consider for example a real-time device programming, or an air traffic control software. The later one needs to be stable for years to come, and have minimal downtime.

In desktop programming around 75% of the time is bug fixing. Why does software spends between two thirds to three quarters doing bug fixing instead adding features? Well, last time I've checked, developers were still humans, and they can only keep a limited amount of ideas in parallel; but since they have to focus on memory management, performance, writing useful code, interaction between components, specifications, etc. this will overwhelm quite easily even the best developers.

Test Driven Development (TDD) is a software methodology created to reduce the time of staying in bug fixing "mode". The best qualities of it are:

detect bugs as early as possible

has several tests that have input scenarios for the software, and expect some output.

makes the code to trigger feedbacks to the developer if something wrong happens, before a QA analysis. or in the much worse case, a user noticing it.

Which are the steps to do TDD?

since it is named test driven, you should write your tests first, before you write the code. Or if the code exists, make tests to reflect the interface (without assuming the implementation is even better).

make your tests pass with minimal code in the implementation side.

refactor your code to be as good as you want, as long as it doesn't break the tests

As an example let's say that your application uses nUnit framework to do the unit tests, which are small programs that define a collection of tests.

Here is a test that checks in a real world application if one document has a right working Undo function:

using System;
using NUnit.Framework;
using TreeData.AttributeInterpreter;
using TreeData.NaroData;

namespace NaroTestSuite.TreeData
{
[TestFixture]
public class UndoRedoTests
{
    [Test]
    public void UndoAppliedEmpty()
    {
        DefaultInterpreters.Setup();
        Document doc = new Document();
        Assert.AreEqual(0, doc.Root.Interpreters.Count); // assert 1
        doc.Transact();
        doc.Root.Update<IntegerInterpreter>().Value = 2;
        Assert.AreEqual(1, doc.Root.Interpreters.Count); // assert 2
        doc.Commit();
        Assert.AreEqual(1, doc.Root.Interpreters.Count); // assert 3 
        doc.Undo();
        Assert.AreEqual(0, doc.Root.Interpreters.Count); // assert 4
    }
}
}

It is easy to write tests? Well, you need to define your expectations (or assertions) - things that you believe to hold true. Here are the normal expectations for a class that store a document in a doc.Root tree data (from the example above):

a newly created document is an empty one and an empty document will have no attributes (assert 1)
after I will add an integer attribute the attribute count should increase with 1 (assert 2)
after I will try to save the status of the document (after a "commit") the document should not change the attribute count (assert 3)
after I do an Undo, the document will decrease to original document count, so it will be zero (assert 4)

Making tests first will do a very important thing for the developer, it will give to it concrete cases how the actual implementation classes (the tested ones) are used and this means real documentation. Also, using a tested class and if the specified class has the tests passing, will mean that some problem is actually coming from another part of the application, or from an incorrect usage of that class in the production code. This inherently removes a lot of assumptions about what breaks and why.

A great thing also is that tests are often much smaller than the entire application. So debugging it will reduce to debugging of the latest usage of the document, is not the entire application that may not work with Undo function.

How about regression testing?
Regression Testing (RT) is almost the same as TDD but is done after application is written (for instance to an user), there is a test written "to not happen again". RT has some downsides:
- the developer (or QA) who writes the test can get the application architecture. This may mean that we can create a test to pass our code, instead our code to pass our tests
- at development time, there are no tests to check if a component is working (excluding the developer will debug the program again and again)

Should you use RT? Yes, definetly! RT appears in ways that application you have never expected to crash or to run, does so, and where you don't want it. Also, the user bugs are great to be tracked. A flawed component will most probably crash again. There is a QA 80/20 theory which says: 80% of errors are in 20% of code. TDD will say that for your cases your code will work correctly. But still there are your tests, which may not reflect the real life cases.

As in our example: who creates a single document to store only one integer in it?

Conclusion
We've shown several steps on how to implement TDD, we've been over a minor test case, and we've outlined several advantages of using TDD. We've did a short comparison of TDD with RT.

I hope this will stir your appetite for TDD at least as we're having it here at freeopenidea.

Major facelift on freeopenidea.blogspot.com

2009-04-23T10:20:00.000-07:00

As you can see, this blog it's looking now much more nicely. This happened since I got some spare time, and also because of the following opensource/free tools:

gimp and firefox (with firebug).

And of course, my mighty operating system: ubuntu.

MagicGroup 1.2.0 is out

2009-04-10T12:54:00.000-07:00

It makes me great pleasure to announce you that MagicGroup 1.2.0 is out.

MagicGroup is a plugin for Eclipse that allows you to group the files you're working on, in a logical way. A longer description of it, you can find in a previous post of mine.

The changes are:
1. Mercurial source code is available on sf.net. Of course, it is EPL and GPL3.
2. MigLayout is now used for the popup used for renaming and creating groups.

Here is a quick "before and after" using MigLayout:

Before

and

After

The plugin is available for download here:
https://sourceforge.net/project/showfiles.php?group_id=224162&package_id=271060&release_id=674924

Have fun.

PostgreSQL bad practices

2009-04-08T06:57:00.000-07:00

I was reading the "Tip of the Day" in pgadmin3, when I found this gem:

It is good practice to build application logic into the database itself by using functions and views. This ensures that different front-ends to your products will always see the same views of data and update and modify data in the same way. Better yet, you only have to write it all once for all front-ends!

While the sentence itself, does have some truth it it, in my opinion is misleading. I don't think it's good practice, but rather bad practice. I don't deny that there can be valid, performance related reasons to actually use functions and views (my big problem is with functions, not views, since views are pretty standardized) in the database, but let's be honest: the moment that you have stored procedures in the DB you are married to that vendor of the DB.

Be that vendor PostgreSQL, or even Oracle, it's obviously the same thing; and it's not good practice to be tied to a vendor.

Another issue that I have against this, is that you actually split your business logic into several places. While this doesn't fully invalidate the DRY principle (Don't Repeat Yourself), since really, you don't repeat yourself, it has a sneakier drawback:

Your logic is not found anymore in only one place, but rather divided over different (and most of the time totally different) places (and architectures). It can even be 2 different machines. This alone can make debugging a really tough time.

Thus I find approaches like Hibernate Validators much more enjoyable for the same task. You have your constraints and business logic over the domain in only one place. They can't do complex DB operations, but I think most of the time this can be resolved via Object Oriented programming and some nice services.

As people on the Internet tend to get really heated, I want to outline this again: I'm not saying that stored procedures have no place in an application.

What I am saying though, is that you should be really careful when adding them in the application in the first place. I would go and argument that encapsulating them in a service, that is a wrapper over the stored procedure, so at any given time later to be able to change it for a different DB would be a nice approach.

Conclusion

Here are my 2 cents regarding the previous Tip of the Day:

Don't get tied to a single vendor.

Keep your business domain in a single place.

Have clear boundaries on the stored procedure call, to be able to replace it, if you can't live without it.

I'm a hacker... NOT

2009-03-27T08:53:00.000-07:00

Recently I had the pleasure to navigate through milw0rm's exploits. A lot of them are pretty much kryptonite for me, but I think this (milw0rm) is a great place to learn more about security and expand general knowledge about how the exploit works... with more of a "hands on" approach, then security by obscurity promoted by some weird companies.

Until I found this "exploit". It supposed to be some sort of a bug for Firefox 3.0.5, and exposed as "Firefox 3.0.5 Status Bar Obfuscation / Clickjacking".

Let's get a few things straight. Almost all recent browsers represent the page internally under a structure called Document Object Model (DOM). The defacto programming language, that again, almost all recent browsers implement, is ECMAScript, better known under the name of JavaScript.

JavaScript code that runs inside the browser can access the DOM and modify the DOM in almost every imaginable way - actually because of this extreme flexibility the whole Web 2.0 concept was born out.

Back to the main topic. If you have code like this (taken from the "exploit"):

25 <a href="http://www.google.com" onclick="updatebox(event)"><font
26 style="font-family:arial;font-size:32px">http://www.google.com</font></a><br>

that calls a function like this:

 6 <script>
 7 function updatebox(evt) {
 8 mouseX=evt.pageX?evt.pageX:evt.clientX;
 9 mouseY=evt.pageY?evt.pageY:evt.clientY;
10 document.getElementById('mydiv').style.left=mouseX-1;
11 document.getElementById('mydiv').style.top=mouseY-1;
12 }
13 </script>

then please don't say it's an exploit, just say it's expected functionality from any decent browser that has JavaScript enabled.

Notice the DOM manipulation right there: document.getElementById('mydiv').style.left=mouseX-1;

And since we can do DOM manipulations, there's no need to move divs around for the "clickjacking". We can just change the href's target and that's it:

 3 <body>
 4     <script language="JavaScript">
 5         function navigate(element) {
 6             element.href = "http://milw0rm.com";
 7         }
 8     </script>
 9 
10     Valid link:
11     <a onclick="navigate(this);" href="http://www.google.com">www.google.com</a>
12 </body>

On a funny note: Hey, this code it's even cross browser!! It also works on several other browsers. Thus I give you: "Firefox/Opera/Safari/IE/... Status Bar Obfuscation / Clickjacking".

You could visit google.com for more information. :P

Groovy scripting

2009-03-25T03:20:00.000-07:00

I got lately very pissed off on svn management, especially when trying to commit. The reason behind it, is that I want to be able to pick what files to commit, also by looking at the actual changes in the files.

Do you remember once that I wasn't a very big fan of one liners? So... how many lines of code do you need in order to develop a real application which looks like this:

(that does svn commit management - being a wrapper over the svn command)?

The answer is... 207. (including white spaces, layouts, etc.). All that you need is groovy and MigLayout.

And here goes the code:

#!/usr/bin/env groovy

import net.miginfocom.swing.*
import java.awt.event.*
import javax.swing.*
import javax.swing.event.*
import javax.swing.text.*
import java.awt.*

import javax.swing.table.AbstractTableModel

class SVNRecord {
    String path
    String change
    boolean lock
    boolean checked
}

class MyTable extends JTable {
    public void init() {
        for (int i = 0; i < 3; i++) {
            this.columnModel.getColumn(i).maxWidth = 16
        }
    }
}

class MyTableModel extends AbstractTableModel {
    def records

    public String getColumnName(int column) {
        switch(column) {
            case 0:
                return "X" // select it for commit
            case 1:
                return "L" // lock status
            case 2:
                return "M" // modified
            case 3:
                return "Path"
        }
    }

    public Class getColumnClass(int c) {
        return getValueAt(0, c).getClass();
    }

    public int getRowCount() {
        return records.size()
    }

    public int getColumnCount() {
        return 4
    }

    public Object getValueAt(int row, int column) {
        switch(column) {
            case 0:
                return records[row].checked
            case 1:
                return records[row].lock
            case 2:
                return records[row].change
            case 3:
                return records[row].path
        }
    }

    public boolean isCellEditable(int row, int column) {
        column == 0 ? true : false
    }

    public void setValueAt(Object value, int row, int column) {
        records[row].checked = value
    }
}

String.metaClass.system = {
    new Runtime().exec(["/bin/bash", "-c", delegate] as String[]).in.text
}

def records = null

JFrame wnd = new JFrame()
wnd.title = "commit"
wnd.defaultCloseOperation = JFrame.EXIT_ON_CLOSE
wnd.layout = new MigLayout("fill", "", "[growprio 1][]unrelated[growprio 1][]")
def jtable = new MyTable()
jtable.model = new MyTableModel()
jtable.model.records = records
jtable.selectionMode = ListSelectionModel.SINGLE_SELECTION
jtable.rowSelectionAllowed = true
jtable.columnSelectionAllowed = false
jtable.init()

def reloadChangedFiles = { ->
    records = """
        svn stat
        """.system().split("\n").findAll { line ->
            ! line.startsWith("?")
        }.collect { line ->
            def m = line =~ /(.*?)\s+(.*?)\s+(.*$)/
            m.matches()
            def record = new SVNRecord()
            record.path = m.group(3)
            record.lock = m.group(2)
            record.change = m.group(1)

            record
    }
    jtable.model.records = records
}

reloadChangedFiles()

def createPanel = { ->
    JPanel result = new JPanel()
    result.layout = new MigLayout("fill")
    return result
}

JPanel leftPanel = createPanel()
def topPanel = createPanel()
def scroll = new JScrollPane(jtable)
topPanel.add new JLabel("File List:"), "growx"
def refreshButton = new JButton("Refresh")
topPanel.add refreshButton, "wrap"
topPanel.add scroll, "width 300::, grow, span, wrap"
def bottomPanel = createPanel()
bottomPanel.add new JLabel("Diff:"), "wrap"
def diffTextPane = new JTextPane()
def textPaneScroll = new JScrollPane(diffTextPane)
bottomPanel.add textPaneScroll, "width 300::, wrap, grow"

def verticalSplit = new JSplitPane(JSplitPane.VERTICAL_SPLIT, topPanel, bottomPanel)
leftPanel.add verticalSplit, "grow, wrap"

JPanel rightPanel = new JPanel()
rightPanel.layout = new MigLayout("fill, top")
rightPanel.add new JLabel("Comment:"), "top, wrap"
def commitTextPane = new JTextPane()
rightPanel.add new JScrollPane(commitTextPane), "growx, height 200::, wrap"
def revertButton = new JButton("revert")
rightPanel.add revertButton, "growx, wrap"
def commitButton = new JButton("commit")
rightPanel.add commitButton, "growx, wrap"
def closeButton = new JButton("close")
rightPanel.add closeButton, "growx, wrap"

def horizontalSplit = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftPanel, rightPanel)
horizontalSplit.oneTouchExpandable = true

wnd.contentPane.add horizontalSplit, "grow, wrap"

wnd.pack()

def selectedIndex = -1

Style textStyle = diffTextPane.addStyle("red", null);
StyleConstants.setForeground(textStyle, Color.RED);
textStyle = diffTextPane.addStyle("blue", null);
StyleConstants.setForeground(textStyle, Color.BLACK);

// actions
jtable.selectionModel.addListSelectionListener({ event ->
    println jtable.selectedRows[0]
    if (! event.valueIsAdjusting) {
        selectedIndex = jtable.selectedRows[0]
        StyledDocument document = new DefaultStyledDocument()


        def diffText = "svn diff ${records[selectedIndex].path}".system()
        document.insertString(document.endPosition.offset, diffText, null)
        diffTextPane.document = document
    }
} as ListSelectionListener)

revertButton.addActionListener({ event ->
    """
    svn revert ${records[selectedIndex].path}
    """.system()
    records.remove(selectedIndex)
    jtable.revalidate()
} as ActionListener)

closeButton.addActionListener({ event ->
    System.exit(0)
} as ActionListener)

commitButton.addActionListener({ event ->
    def fileList = records.findAll { record ->
        record.checked
    }.collect { record ->
        record.path
    }.join(" ")
    """
    svn commit -m "${commitTextPane.text}" $fileList
    """.system()
    System.exit(0)
} as ActionListener)

refreshButton.addActionListener({ event ->
    reloadChangedFiles()
    jtable.revalidate()
} as ActionListener)

wnd.visible = true

Notice that I'm heavily using closures as means to define actions in the GUI and have access to the context variables. Also the reason to pick MigLayout wasn't done at random. I think it's the best layout manager out there (you'll need it in ~/.groovy/lib).

I hope it helps.

Using DLR in your application from C#

2009-03-09T04:14:00.000-07:00

What is DLR?

DLR is a high level framework used to create dynamic language compilers on top of .NET Framework. Some of the advantages of it is that any language it registers to that framework, thus changing the support to any DLR language, is mainly adding a reference that consists in the language implementation and one string to identify it. This post will focus on IronPython which is better documented, but in fact it should be the same as using IronRuby that uses the same DLR engine (so GetEngine ("rb") should be used instead).

What does a DLR language implementation consist in?
Firstly, a ScriptEngine class is the implementation of the language itself (it is defined under the Microsoft.Scripting.Hosting). This ScriptEngine will offer you a DLR based engine that is offering all that you will need to do with the language.

Let's create one:

ScriptEngine engine = Python.CreateEngine(); // if you use the direct IronPython
                                             // interface to do so or (more generic):
engine = ScriptRuntime.Create().GetEngine("py");

From this engine you get an instance of the IronPython runtime. How can you add references? As the dynamic languages have multiple modules (that might depend from one language to another), there is a need to define such modules, and one of the predefined modules, that is defined to work with .NET types is named clr.

ScriptRuntime runtime = engine.Runtime;
runtime.ImportModule("clr");

Next, you will create a scope that executes in "the context" of your program. Think to scopes, as a new method call. All contexts share the same runtime! Thus if you want one scope to use CLR, but another one to be restricted, you should create two engines! Every scope has its own variables defined into it.

ScriptScope scope = engine.CreateScope();

From now on, you can execute your code in ironPython when you create a Scope.

The C# code to execute an arbitrary code is like the following:

void ExecutePythonCode(string code)
{
    try
    {
        ScriptSource source = engine.CreateScriptSourceFromString(code, SourceCodeKind.Statements);
        source.Execute(scope);
    }
    catch (Exception e)
    {
        MessageBox.Show(e.Message);
    }
}

Not powerful enough yet? If you have your own variables and you want to modify them from the scripting, all you have to write is:

scope.SetVariable("pythonVarName", yourCsVariable);

And the new variable is mapped dynamically, so you can change the data in it as is a python class instance. So you may write in your script: pythonVarName.ToString() at any moment!

One last note: how to import from IronPython System.Windows.Forms namespace, or any other instance: you have to do two things:

adding a reference to necessary assembly,

do the "using" C# part, means to import the namespace to your program

clr.AddReference("System.Windows.Forms")
from System.Windows.Forms import *

IE6, Select, Z-index and a Prototype solution

2009-03-02T03:57:00.000-08:00

Aren't you pissed off about that IE6 (old since the beginning of the world) bug that ignores the z-index for all the combos in the page? Thus all the combos from the page creep on the top div, like mushrooms in an Amazonian forest.

I know that people should just throw down the toilet that "magnificent" browser, but sometimes the company you work for, decides to support IE6, so you really don't have a choice.

Anyway, here are some functions that use prototype, that workaround this issue by hiding/showing all the combos on the page if the version of the browser it's IE6.

 1 function showSelects() {
 2     $(document.body).select("select").each(function(select) {
 3         select.show();
 4     });
 5 }
 6 
 7 function hideSelects() {
 8     $(document.body).select("select").each(function(select) {
 9         select.hide();
10     });
11 }
12 
13 function isIE6() {
14     return Prototype.Browser.IE && navigator.appVersion.indexOf("MSIE 6.0") != -1;
15 }

That's pretty much it. I hope you'll find it useful.

Dynamic Method Creation

2009-02-20T04:51:00.000-08:00

I don't know about you guys, but I think programming it's hard. It's hard, because we have a lot of technical challenges, made of functional and non-functional constraints. We need to learn their whole business in order to be able to to craft their product as they wish.

And this is hard.

We are forced to learn so many things, that we can not base our knowledge on our brain, but want the tooling (IDEs) to do autocomplete for us. This is embarrassing at least. We create such complex systems that, most of the time, without tooling we can not feasible maintain them anymore.

And there is where dynamic languages come to the rescue.

What if the objects that we're modeling upon could deduce our intent in using them? They weren't be some dumb data structures, but could actually figure out from what we're asking them what we mean, and "compose" their behavior transparently to provide us what we want.

Take a look at the following code (it's not very useful, but it's a good starting example):

 1 class CoolObject {
 2     public def invokeMethod(String name, def args) {
 3         if (name.startsWith("say")) {
 4             def words = []
 5             def currentWord = ""
 6 
 7             name.substring(3).each { letter ->
 8                 if (letter.equals(letter.toUpperCase())) {
 9                     words.add currentWord
                    currentWord = ""
                }
                currentWord += letter
            }
            words.add currentWord

            print "${args[0]} you are"
            words.collect {
                it == "Dash" ? "-" : it
            }.each {
                print "$it "
            }
            println ""

            return args[0]
        }

        super.invokeMethod(name, args)
    }
}

CoolObject coolObject = new CoolObject()

println coolObject.saySomeoneCool("John")
println coolObject.saySomeoneReallyDashReallyCool("Mary")
println coolObject.toString()


As you can see, "cool object" doesn't have any method named saySomeoneCool or saySomeoneReallyDashReallyCool. But it knows how to interpret them in case you call them. And I can still call the existing functions (toString).

When running it with groovy the following output goes out:

John you are Someone Cool
John
Mary you are Someone Really - Really Cool
Mary
CoolObject@1267649

To this point this is just another way of sending arguments (using the method name instead of creating a generic method "say" and giving there whatever needs to be told) - which is not mind blowing. The only cool thing, is that you can actually get a feeling on what it does from the naming only.

But here are some places where it is really neat to have the capability of "creating" methods on the fly:

Finders:
object.findWhereNameIsLikeAndSurnameEquals("Moo", "Foo")
compared to
object.findWhereSurnameEqualsAndNameIsLike("Foo", "Moo")

They have the exact same meaning, and you can deduce it from the method names. (They are actually widely used already, in frameworks like "grails").

Extended behaviour:
object.runInTransactionMooFunction(mooArg1, mooArg2, ...)

Let's assume that object has a mooFunction, runInTransaction could ensure starting and committing a transaction, or rolling back if something bad happened, etc.

(actually "Finders" and "Extended behaviour" are belonging in the same AND kind of functionality -
run this AND that -, without duplicating code, or creating bogus functions that just link them; I could translate the runInTransactionMooFunction as startTransactionAndMooFunction).

I could still call object.mooFunction(mooArg1, mooArg2, ...) if I've managed my own transaction.

"Correcting" behaviour:
object.toZtring();

Could actually search for the nearest named method, call it (because it's obviously my intent),
and print a warning that I'm using the wrongly named function.

Transparent proxying/decorating:
It's really-really trivial to create now proxying of any kind, and change the behavior of some methods without using inheritance.

This doesn't want to be by any means a complete list of what you can do if you are able to aggregate behavior just by analyzing the message passed to you.

But it is meant to show you the immense capabilities between the "simple" analyzing of the method name called, and interpreting that for behavior, instead of just creating endless methods.

As an end note, I don't think that using this kind of approach would totally remove the need for tooling. But I am certain, beyond any reasonable doubt, that it will reduce our dependency on it.

And our code will express more our intent.

JavaFX training

2009-02-17T07:41:00.000-08:00

Who hasn't heard of it? Who doesn't want to know about it? For all of you java web developers out there, this should be an interesting course. And it's free for SDN members!

(If after the Solaris playground you're not yet an SDN member, I am wondering what's wrong with you people anyway :).)

This is a training course I really want to take.

I'll come back in around a month with updates.

Play with OpenSolaris on a remote virtual machine

2009-02-05T13:34:00.000-08:00

Sun has made available (for registered members of Sun Developers Network) one hour of free play on one of their virtual machines loaded with Solaris.

Link: https://learning.sun.com/solc/course/sandbox-1

You can play chess:
... you can see the package manger in action (and remove or add programs, since you have root access):... and, yes, (the ahead of its time) zfs it's also there:
How cool is that?

I just wait to test it in VirtualBox.

SCJP - Sun Certified Java Programmer - You think you're good?

2009-02-05T08:57:00.000-08:00

So you think you know Java?

Sun made free a simulation of their SCJP test. All the questions are from plain java.

http://www.sun.com/training/certification/assessment/055-Jintro.jsp

Come on, go ahead and try it... it's free anyway.

Writing Better Code - A Step By Step Analysis

2009-01-16T16:15:00.000-08:00

I was asked recently to evaluate the following function:

public class SortUtils {
    public static <K, V> void sortMapByValueSize(Map<K, Collection<V>> mapArg) {
        if (!(mapArg instanceof LinkedHashMap)) {
            throw new IllegalArgumentException(
                    ">>> The argument has to be a LinkedHashMap in order for the swapping to be saved.");
        }
        List<K> keys = new ArrayList<K>(mapArg.keySet());
        List<Collection<V>> values = new ArrayList<Collection<V>>(mapArg
                .values());
        List<Collection<V>> copyOfValues = new ArrayList<Collection<V>>(values);
        genericSortBySize(copyOfValues);
        mapArg.clear();
        for (int i = 0; i < copyOfValues.size(); ++i) {
            mapArg.put(keys.get(values.indexOf(copyOfValues.get(i))),
                    copyOfValues.get(i));
        }
    }

    public static <T> void genericSortBySize(List<Collection<T>> x) {
        int n = x.size();
        for (int pass = 1; pass < n; ++pass) {
            int i = 0;
            for (ListIterator<Collection<T>> li = x.listIterator(0); li.hasNext()
                    && (i < n - pass);) {
                Collection<T> tmp = li.next();
                i = x.indexOf(tmp);
                if (tmp.size() > x.get(i + 1).size()) {
                    Collection<T> temp = tmp;
                    li.set(x.get(i + 1));
                    li.next();
                    li.set(temp);
                    li.previous();
                    ++i;
                }
            }
        }
    }
}

This code is supposed to receive a LinkedHashMap with some generic keys, and as value a collection of stuff. It should sort the items by the number of the elements in the collections.

When I see this kind of code, I always have a mini seizure. First of all, because I can't figure out from the first look what is that code really doing. Second of all I can smell problems. (Yes, code does smell).

This one has a peculiar stink, and unless you're not completely blind, at least the function genericSortBySize should raise you some questions. For starters: what does it do?

At a first sight it's a naive sorting done via bubble sort. Thus the complexity is at least O(n²). That's a bad sign.

There are others: the variables are written in an encrypted style. You need to be the actual programmer who wrote them to really figure out what's happening there.

Are you watching closely? (to quote a certain magician)

I've mislead you a bit. What's the complexity of the algorithm come again? You think it's O(n²)? If yes, then you're wrong. I've said "at least". This one has a neat "feature" of having the complexity... drums beating.. O(n³). In case you didn't see it, look again in the code: Yup, it's that indexOf.

                i = x.indexOf(tmp);

It is clearly that the original author didn't knew about the existence of Collections.* algorithm functions. One of them is called sort and guarantees O(n * log(n)) complexity.

Thus we could refactor that method like this:

    public static <T> void genericSortBySize(List<Collection<T>> collectionsList) {
        Collections.sort(collectionsList, new Comparator<Collection<T>>() {
            public int compare(Collection<T> o1, Collection<T> o2) {
                return o1.size() - o2.size();
            }
        });
    }
}

Now, not only the complexity went from O(n³) to O(n * log(n)) but also we can read the code, and we fixed a bug present in the code. If you didn't see it, don't worry, it's easy to miss it in that mess. I'm not going to pinpoint the bug, but believe me, it is there, and I'll leave it as an exercise for the careful reader.

Another problem arises, now that our code is more clearer. It's located here:

        for (int i = 0; i < copyOfValues.size(); ++i) {
            mapArg.put(keys.get(values.indexOf(copyOfValues.get(i))),
                    copyOfValues.get(i));
        }

The way the algorithm was designed is in such a way, that even if we fixed that, we still have O(n² * m) complexity. Yup, that's an M since the searching for the key is using again... indexOf. The problem with this brilliant construct is how it's implemented. It will actually iterate over the each element of the list and call equals on each element, with the argument it received.

The problem is, you've guessed, that our elements are... erm... Lists. Thus, equals will go into them as well, and call equals on each argument. For our benchmarks, we've used numbers. In real life it could have been much more costly in terms of processing power. Assuming all the lists have an equal number of elements (let's say m), the complexity is now O(n² * m). (If you've watched closely as instructed, you would know that the previous function had it as O(n³ * m)).

Thus the only viable option remain the full rewriting of the code. The original author of the code didn't knew probably of the existence of TreeMap. TreeMap has this very nice property that the insert/remove on it have the "cost" of O(log(n)), but it keeps the items sorted inside.

Thus, all we really need to do is add the items in a TreeMap [n items * log(n) per item, should be a cozy O(n * log(n))]. Then all we need to do is to iterate on the sorted keyset and just put the values in the other map. (again, under O(n * log(n)) ).

Thus the code now looks like (we even kept the same API for our external users):

class CollectionHolder implements Comparable<CollectionHolder> {
    Collection collection;
    int index;
    static int lastIndex;
    
    CollectionHolder(Collection collection) {
        this.collection = collection;
        this.index = CollectionHolder.lastIndex++;
    }
    
    public int compareTo(CollectionHolder other) {
        int cmp = this.collection.size() - other.collection.size();
        if (cmp == 0) {
            return this.index - other.index;
        } else {
            return cmp;
        }
    }
    
    public boolean equals(Object obj) {
        return this == obj;
    }
}

public class SortUtils2 {
    public static <Key, Value> void sortMapByValueSize(Map<Key, Collection<Value>> mapArg) {
        validateArgumentMap(mapArg);
        Map<CollectionHolder, Key> valuesMap = new TreeMap<CollectionHolder, Key>();
        
        sortArgumentMapIntoValuesMap(mapArg, valuesMap);
        clearArgumentMap(mapArg);
        putValuesMapIntoArgumentMap(mapArg, valuesMap);
    }

    private static <Key, Value> void validateArgumentMap(
            Map<Key, Collection<Value>> mapArg) {
        if (!(mapArg instanceof LinkedHashMap)) {
            throw new IllegalArgumentException(
                    ">>> The argument has to be a LinkedHashMap in order for the swapping to be saved.");
        }
    }

    private static <Key, Value> void sortArgumentMapIntoValuesMap(Map<Key, Collection<Value>> mapArg,
            Map<CollectionHolder, Key> valuesMap) {
        for (Key key : mapArg.keySet()) {
            valuesMap.put(new CollectionHolder(mapArg.get(key)), key);
        }
    }

    private static <Key, Value> void clearArgumentMap(
            Map<Key, Collection<Value>> mapArg) {
        mapArg.clear();
    }

    private static <Key, Value> void putValuesMapIntoArgumentMap(
            Map<Key, Collection<Value>> mapArg, 
            Map<CollectionHolder, Key> valuesMap) {
        for (CollectionHolder holder : valuesMap.keySet()) {
            mapArg.put(valuesMap.get(holder), holder.collection);
        }
    }
}

You might say that maybe we didn't save that much... For those of you still living in denial, here are some benchmarks. I've run the initial code over the same kind of arrays. They were having either 1, 11, 21, or 31 elements, and the elements were having the same value (they were an Integer, with the value 10), and more and more collections we're added (up to ~600).

It's very important since whenever you see indexOf() the complexity it's not O(n), but O(1). A lot of comparisons are now gone away. It is still O(n²).

The next thing I've did, was just to have distinct numbers in the arrays. The times skyrocketed:

We went from milliseconds to seconds in a blink. An the last implementation, the one with the TreeMap follows:Except a single one (most likely caused by scheduling), all of the times where less or equal 4 milliseconds.

Conclusions:
1. The wordpress team says "Code is poetry". Make your code at least human readable. The bugs should stand right at you if any. (if not, see pt. 4)
2. Understand your underlying API and find the algorithms implemented by your platform. (even C and C++ have them - hint for C++: STL and boost, search and get aquinted with them, before writing naive code).
3. Understand what the basic functions do on the collection classes. You might not want to popFirst from a queue if it's implemented with a list.
4. Refactor your code to get better insight, and don't let you're code rot.
5. Write tests. They are the only (slim as it is) guarantee that your code does what you think it does. The bug found in this code was found by a test. I didn't just "see" it.
6. Performance does matter, but it's driven from the algorithm, not from "clever hacks that work". You can never prove the performance of a hack.

Just Dilbert

2008-12-08T12:30:00.000-08:00

A short program to count lines of code

2008-12-03T04:51:00.000-08:00

I've just seen this small C# program and I wondered how would it be done in groovy. My solution looks like this:

#!/usr/bin/env groovy

def funcName = (args.length > 0 && args[0] == "/s") ? "eachFileRecurse" : "eachFile"
def lineCount = 0

new File(".")."$funcName" { f ->
    if (f.isFile()) {
        f.eachLine { lineCount ++ }
    }
}

println lineCount

It is not a "one liner" (tm), but I don't believe in that.

And some bash sayings:

raptor@raptor-laptop:~/foo$ cat countLines.cs | tr -s " " " " | wc
17 31 343
raptor@raptor-laptop:~/foo$ cat countLines.groovy | tr -s " " " " | wc
13 37 235
raptor@raptor-laptop:~/foo$

(tr is used to minimize the impact of indentation in the counting)

If someone has a solution in Python (or any other language for that matter), I would be really anxious to see it.

Groovy and bash bring their love to the next level

2008-11-29T11:03:00.000-08:00

You're hearing a lot these days about polyglot programing, or even
creating console scripts with groovy.

While I don't deny the power of using pure groovy shell scripts, I do believe that for a lot of tasks there is a true power in the shell. And it really doesn't make any sense to try to change that.

But as you already may know, groovy can expand types, by adding methods at runtime. What we will do, is add a new system method to the String class.

Now you can have code like the following:

// version changed as per Ted's comment - thank you Ted!
String.metaClass.system = {
new Runtime().exec(["/bin/bash", "-c", delegate] as String[]).in.text
}

def localVar = "GROOVY"

println """
echo "localVar is $localVar and SHELL is \$SHELL"
localVar="SHELL"
echo "--------------------------------------"
echo "localVar from groovy is $localVar and"
echo "localVar from shell is \$localVar"
""".system()

On the contrary, if no variables from groovy would be used, we can then use the triple ''' instead of """

'''
bashvar="foo test"
echo $bashvar # regular bash, no escaping of the variable is needed
'''.system().split("\n").each { line ->
println line
}

As you can see the second aproach is great if you want pure bash calls.

Of course, the command launched doesn't need to be necessarily bash (it could be also, perl or python, or whatever scripting language you want as long as you can give it as a parameter the script to evaluate).

But now it's easy to have the best of the both worlds: Java and bash.

My objects are returning!

2008-11-17T02:13:00.000-08:00

Warning: this, by my standards, is a really long article.

Being warned, have you ever wondered, why some people really love Object Oriented Programming?
I am one of them, that believes that almost anything should be an object.

But what are objects? I have read that objects are data and code. Is this simplistic approach true? Is this all that it is with objects?

I've read once a comment that objects are no such a big deal since there were ADTs (Abstract Data Types) existing even before objects.

Well, let us just dive in a bit and see what objects really are. Lets go first to the real world.

Objects can be viewed really simplistic: Car, or tree, or house - sound familiar? Identifying an object by name, but without a specific reference is actually a Class in the programming world. You don't know what specific object is, but you know its type.

But most likely if you are a car designer my simple wording might not suffice. When you hear "car" you immediately think in wheel, doors and tire terms. You decompose the original object into its components. While this has nothing to do with its original value, this clearly shows that objects are hierarchical.

Furthermore we can see that objects are composed, and they have a structure. Nothing is really random. Everything has its place.

But because we have a structure between objects, we can now navigate between objects, only by using wording descriptions, and we can identify other objects by meaning, or position. Identifying by name it's not mandatory anymore.

"At the middle of the door we have a thingie that normal people grab and twist in order to open the door". In your mind now it is clear that I am talking about a handle.

In groovy this would look like:

println door.open // door.isOpen() should return false
def me = new Human()
def handle = door.middle.content
me.grab( handle ) // setting a connection between a person and the handle
handle.turn() // the handle is either turned by me, either turns automatically
println door.open()

Of course, if the door would be locked, handle.turn() would most likely have thrown a DoorIsLocked exception and call alarm.ring().

The cool thing to remember is that I've used the handle only by referencing it via the door. I could have use it without knowing it is named a handle. Nor I need to know that the handle used wrong, triggers the alarm.

Thus naming bundles together an object with description data, behavior and it gives it meaning.

Short recap on what do we know about objects:

they can be viewed as simple or complex
in order to reference an object we either use direct naming "cat", or referencing it via its relations to other objects "cats end" (tail)
they have behaviour (cat meows, door opens, handle turns, etc.)
they have state (alarm rings if the door is locked, or door opens)

Because we are in the software world, there is only one thing we should add about "our" objects, compared to the real world.

they represent concepts

They abstract a real object - for example a boat object would be just a reference, to a real boat, floating somewhere. Because they are only concepts, you could change them to reflect your view of the world. Nothing is carved in stone.

Now here is the interesting part: programming using objects is very-very easy. You just model each object from the real world to a concept in the software, and continuously refine it ("refactor" for you, the fancy ones out there). The seems pretty easy. The problem is that the number of objects is quite big compared to the memory and speed of our computer.

Thus, tricks must be involved to make this objects "live" somewhere, even if all of them couldn't be loaded all at once in memory. Here SQL comes into play. Via SQL we can represent our objects as "data", to persist them in the database, and when needed to load them from database. Some guys thought that using this, we could expand our objects lifetime.

Another idea was to have some objects on one machine, and some other objects on other machines. Thus, we could share these objects, and then by calling some kind of service, obtain a reference to the object, and then manipulate it remotely. (CORBA, RMI, and co., could easily fit in).
Other guys (cough, J2EE, cough) unfortunately thought: why bring references to the object? network is slow, etc. etc., so we'll just bring a Value Object over the wire. Which is basically only the data of an object, without its behaviur. (By analogy it would be a pig without life, good for hot dogs, pork chops or whatever, but it can still do nothing).
So you want to use the pig in a service? Well, just send it back, and we'll resuscitate it via some DAO method. (As a side note, if you're using Spring and Hibernate a ping-pong with the pig back and forth to the service, and you're out of luck. Most likely there is nothing more you can do for your pig.).

Another problem, was that there are objects that cross classes boundaries. (A flying boat, is it a Boat?, is it a Plane?, or is it Superman? :) ). These kind of things, some may argue, are complex to model as objects. Also some items couldn't be, at that time, mapped easily on objects. What about transactions? Should they be objects?

And what about stateless requests? Like HTTP. How about all this Web 1.0, Web 2.0 thing? How do you get objects when you have nothing to get them from?

This changed the easy OOP programming. Instead, it became a kind of Shrek, an ogre outside, but a warm hearted friend for conaisseurs. It also gave bread for writers of GOF, POSA1, POSA2 and other pattern books. It made things like dependency injection, aspect programming or object relational mapping sound like alien crafted words, where only wizards like Gandalf the Gray, or Saruman could go in their depth.

Languages like C++, Java or C# only accentuated this problem. Their biggest issue is, in my humble opinion, that they either forced the user to classify objects extremely well, either add unnatural complexities (like the long life of Gollum - C++ shines on this one, my precious...). And since we were talking about Superman, if I would have such a construct:

def superman = callSuperman()
assert !(superman instanceof Bird)
assert !(superman instanceof Plane)
assert (superman instanceof Superman)

I can allmost bet you, that if I would have to implement Superman in Java (C#, etc.), since Superman does have the abilities (behaviour) of a Bird or a Plane, Superman would either be a Bird and a Plane at the same time - beat that, you existentialists -, either it would secretly have a bird and a plane in its internals and secretly using them for flying (in some books this would be called composition, but don't rely on that). There is no way I could reuse only parts of an object in a clean way - at least, not that I know of (in Java that is).

So, we've seen what objects are, and we've seen some problems that actually only the software world introduced them.

Now here is where ORM comes into play. (ORM == Object Relational Mapping) ORM can fix one of our main issues - not having all the data. You do remember that I was unhappy because of SQL. Let me expand on why I am unhappy about it.

I like to think that my objects are... erm... objects. Simple as that. But since I can not hold them all in memory I, until quite recently, need tricks like the following (remember the door example):

println door.open // door.isOpen() should return false
def me = new Human()
door.middle = DoorSQLService.loadMiddle(door); // whatever way you are loading doors
def handle = door.middle.content
me.grab( handle ) // setting a connection between a person and the handle
// the alarm it is possible not to be linked to the handle, so we'll add it now:
if (handle.alarm == null) {
 handle.alarm = AlarmSQLService.loadAlarm(handle);
}
handle.turn() // the handle is either turned by me, either turns automatically
println door.open()

Now this totally messes up with our concept of objects. Objects aren't simple anymore. We need services to access them. Also, maybe this services need to be set up to some SQL databases, the loadMiddle and loadAlarm, should be implemented. Are they having any object behavior? They just seem to load data, without any meaning. And beware of the lazy references (references that are not yet initialized since the data was not loaded)!

The trick is that ORM hides all the loading for us. The loading from the DB, and also the saving, is done almost completely transparent. (We need to setup it in the beginning, and from time to time control its transactions, but it's not the SQL Hell (TM) anymore).

Another thing that SQL forces you is to cut your objects in half, data and separate behaviour. For me data && behaviour == functions and data. I don't think objects support that in the strict sense. Imagine an atom: while it is composed of protons and electrons, it doesn't make much sense to separate them. It wouldn't be an atom anymore. I really love how the ancient Greeks used to see the atom: uncuttable, something that cannot be divided further.

A penguin that can fly it is one messed up penguin. And yes, it's a bird. The penguin itself has data and behaviour bundled with it. This it what makes it an object. It shouldn't have the "fly" method in the first place. (Some will rant, that it can throw an IllegalStateException when trying to fly, but I haven't seen penguins doing that... they just crash and die - MethodNotFound way.)

Another thing is that there are better languages out there. No java is not the answer. And neither is C#. One of the languages that truly impressed me was... JavaScript. In JavaScript everything is an object. Hierarchies of objects are not bounded to classes, behavior can just be copied, and so on.

Another issue that was quite hard to do was transaction management. But now, in EJB3 for example, all you need to do is to annotate a method, and there you go, you have a transaction - furthermore, implicitly all the methods of an EJB (EJB == Pojo spelled funny in the EJB3 slang) are services. This transaction also is bounded to the EntityManager (the cool name that is used in the EJB world for the ORM service), so whatever things you add to the entity manager or remove they are persisted automatically.

AspectJ allows you to define objects that will be called in a more flexible way that the normal method invoke, making transaction management a much simpler issue. (on AspectJ I will have a distinct talk).

Furthermore, if you're using JSF (another fancy name for displaying things in the beautiful JEE world), you're binding actual objects to the GUI. Editing a h:inputText would have as result setting the property of an object directly. What gets even neater, with tools like SEAM you can immediately validate things. And it's all in my objects. (By the means of this article I want to thank Gavin King, and I truly think he is a genius for creating Hibernate and Seam, and Brendan Eich - the guy who invented JavaScript, the actual CTO at Mozilla).

If you're using SEAM, you don't even have to worry about stateless calls, there are conversations that keep track of all your objects and they also integrate the transactions usage.

Bottom line:
The way I see an object, as an atomic unit of existence, that has behavior and state (data), and they are inseparable. If you do separate them, there must exist a cleaner way, that doesn't invalidate the whole object concept.

Object programming is simple, but technology constraints made it difficult, many times canceling the basic features of OOP. Fortunately the wheel of technology is turning.

PS: This is pretty much a personal (and as such biased) opinion, made on several years of OOP and non OOP programming, under various languages.

Creating a SHA1 hashing function for PostgreSQL 8.3 and Ubuntu 8.04

2008-11-12T07:15:00.000-08:00

I think everyone needs from time to time this hashing method when it gets
to work with user databases, for maintenance purposes.

As one who migrated from mysql to postgres - (actually I'm still dual using them)
I was surprised to see this very useful function doesn't exist.

Don't worry, it's easy to add it.

On the terminal we first need to add the cryptographic libraries for postgres.
The easiest way is to add the postgresql contrib, that contains a lot of goodies,
and, of course, our crypto libraries. Also it is in the repository already.

$ sudo apt-get install postgresql-contrib-8.3

The next step would be exporting the cryptographic methods (except sha1 unfortunatelly)
into the template from where each newly created database is derived:

$ sudo -u postgres psql template1 < /usr/share/postgresql/8.3/contrib/pgcrypto.sql

(in case you already have existing databases where you would need these functions, just
change template1 to the corresponding database name, e.g.:

$ sudo -u postgres psql proddb < /usr/share/postgresql/8.3/contrib/pgcrypto.sql

)

Now we need to create our sha1 method (I've used the pgadmin3 tool in order to do that,
but you can still use the psql approach for that).
As you can see the actual work is done by the more generic "DIGEST" method - which
unfortunatelly returns a bytea, and converted to a string by the "ENCODE" method.

CREATE OR REPLACE FUNCTION sha1(bytea)
RETURNS character varying AS
$BODY$
BEGIN
RETURN ENCODE(DIGEST($1, 'sha1'), 'hex');
END;
$BODY$
LANGUAGE 'plpgsql'

If you want this method to be in every new table from now on, you could put it in some file
(let's say sha1.sql) and run it against the template1.

$ sudo -u postgres psql template1 < ~/sha1.sql

After that, a simple

select sha1('test')

should return as expected:

a94a8fe5ccb19ba61c4c0873d391e987982fbbd3

Hoping it helps, I'll end here.

gonsole - a dumb groovy konsole

2008-10-14T02:29:00.000-07:00

click the image to start the application

I am truly impressed by konsole on KDE 3. I am using it all the time. They captured a lot of common use cases that I am finding myself quite often doing. While there are similar approaches on terminals (like gnome-terminal, or even konsole from KDE4), until now I haven't seen something near it.

The problem is that there are dumb operating systems out there, where their terminal is a joke. No tabs, no history finding, you can not clear the terminal, no color scheme, so on and so forth... junk - junk - junk.

Unfortunately I do need to use this weak platform for our JEE development, and I do need to run jboss, thus I've made my own "konsole" in groovy and java. Thus the application is name gonsole... And it's one click away via java web start.

You can click the image to start it. I promise you that it will soon be opensource (most likely GPLv3) on sf.net. I am not opensourcing it immediately since it still has some obvious bugs (e.g. when the shell it's exiting, the tab doesn't close).

A Better Static Approach for Utility Classes

2008-06-30T02:23:00.000-07:00

How many times haven't you've seen code like this in a utility class?

package com.blogspot.freeopenidea;

public class StupidLogger {
    public static void log(String what) {
        System.out.println(what);
    }
}

This kind of code is bringing me to tears since it's almost impossible to reuse it. Imagine now a segment of your application that actually uses that code:

package com.blogspot.freeopenidea;

import static com.blogspot.freeopenidea.StupidLogger.log;

public class BusinessLogic {
    public void process() {
        log("hello world!");

        int x = 5;
        int y = 7;

        log("x: " + x + " + y: " + y + " == " + (x + y));
    }
}

and the corresponding main:

package com.blogspot.freeopenidea;

public class MainApplication {
    public static void main(String[] args) {
        BusinessLogic bl = new BusinessLogic();
        bl.process();
    }
}

You're bound to use that version of the StupidLogger for the rest of your life. What's even worse, what if you've already shipped such a version to your client? Most likely he will not redeploy his business jar since it's all fine and dandy. So you need somehow to inject your behaviour into the utility class without changing the business class. Inheritance sounds nice, but here's the trick: you can't change via inheritance the static methods. This is because the actual method call is resolved at compile time. It makes no sense even to have the behaviour from the derived class applied to this one since there is no instance of the class.

Doing a singleton now looks like a better option, but there is still a drawback: you can't use the static import feature if a method it's not static (quite obvious I would add). Thus your code will look something like: StupidLogger.getInstance().log("foo"). As you might see this is not quite fun.

IMHO the best approach is combining these two ideas: create a singleton that uses static methods. So the StupidLogger would look like:

package com.blogspot.freeopenidea;

public class StupidLogger {

    public static StupidLogger INSTANCE = new StupidLogger();

    protected void logImpl(String what) {
        System.out.println(what);
    }

    public static void log(String what) {
        INSTANCE.logImpl(what);
    }
}

So, if you would want to add behaviour to your utility class, let's say support logging via the java logging mechanisms, you inherit from your utility class:

package com.blogspot.freeopenidea;

import java.util.logging.Logger;

public class CoolLogger extends StupidLogger {
    Logger log = Logger.getLogger("com.blogspot.freeopenidea");

    @Override
    protected void logImpl(String what) {
        log.info(what);
    }
}

... and inject it in main

package com.blogspot.freeopenidea;

public class MainApplication {

    static {
        StupidLogger.INSTANCE = new CoolLogger();
    }

    public static void main(String[] args) {
        BusinessLogic bl = new BusinessLogic();
        bl.process();
    }
}

Notice that this doesn't requires any changes in the business component, and yet the behaviour is still changed.

Even if you might consider this article too complex, remember this very important rule of thumb: whenever you blindly use static methods in your utility classes, a small baby rabbit dies.

Beauty of opensource.

2008-06-19T00:31:00.000-07:00

Quite recently I had to stumble upon a big project. You know the kind: with JEE, a lot of EJBs and a big fat Web and Integration tiers (and a lot of other fancy names). The funny thing is that my Eclipse IDE was cluttered with all of these distinct projects, one for Web, one for Business, one for Model, one for Integration, a distinct one for Security, another one for tests and... I hope I haven't missed any of it.

So when I had to edit something (let's say the omnipresent Client) I'll had to edit several files, spanning multiple projects but with the same goal. I'll have the clientHome.jsp, clientQuery.jsp (Web project), ClientRepository.java and it's implementation ClientRepositoryEJB (Integration tier project), ClientService.java, ClientServiceEJB.java (Business tier), Client.java (Model) and ClientTest.java (tests).

The Projects view tend to look like this:
This is still looking quite fun since I've added on purpose only two classes on the model so you could get where I'm going. Imagine that number would be 20 (you do the math). You would have to scroll miles of pixels just to get to that test file, or resource from the web project. You couldn't even see that there were more projects if a fat package, with a lot of java sources, would be opened.

So you would have to remember and use strong naming conventions so you could use the Eclipse's native Ctrl+Shift+R shortcut.

What I would want is something more like the image on the right. I want to group the resources associated with a concept in my own way. Heck, I can even want sometimes the same file to be present under multiple logical groups - a thing impossible in Eclipse (to my knowledge) without creating a link in the Projects View and cluttering even more (!!). The logical groups can structure my thinking - the project view not so much (maybe only at the architecture/component level).

MagicGroup

Long story short, I've got really bored to do this scrolling exercise over and over again at my last job. So I've decided to try and build my own Eclipse plugin that can group files by their logic and not by the filesystem.

Apparently it's not that hard and I'm proud to present you MagicGroup,
my attempt of fixing this project mess. Released under BSD and GPL3 licences (you pick which one) it's very easy to run it (just copy the magicgroup jar from sourceforge into the plugins folder and restart Eclipse). After it's installed go to Window->Show View->Other and pick it.

So where is the beauty of the opensource in all this? The truth be told, I couldn't have done it without the tremendous amount of code out there for the Eclipse platform - which I did use as documenting reference. (Google also seems to be a nice friend when it comes to search for various topics.)

The plugin I wrote itself can be used on any Eclipse (3.3 tested) distro. Let's say you use Aptana for editing PHP, or Eclipse with JSEdit for JavaScript, or just Eclipse with JEE like I do: it doesn't matter. It's very easy to cherry pick your plugins and add value to your Eclipse.

So you can consider this contribution as my humble thank you, back to the Eclipse community.

Test Driven Development

2007-12-14T05:12:00.000-08:00

What It Is (or Abstract)

It is a development method that states test code should be written before the actual program code. In theory (and also in practice)it leverages code development by exposing actual functionality than fuzzy specification.

Why it is used

Many times when the domain of the problem is getting contoured, there are parts of the model that is to be modeled (or parts from the processes of the business process) which are not clearly specified. How the object(s) should be created?, how can we will get the actual feedback if a constraint is invalidated?, how would objects actually behave in their relations with each other^¹?.

By writing the tests upfront, the specification can be clarified of any “uncertain” aspects. Not only that the specification is clarified, but it is also possible for the developers to check the tests as a mean of usage pattern, by seeing the functionality exposed from the model. You can have a hands on experience with the code to be developed and you get a greater insight of how it is supposed to work.

Another thing is that UML, and the actual initial design can not possibly capture the full complexity of the problem in all of its use cases, thus making the domain incomplete even from the early stages of development.

How it is done

The tests are written as if the code to be tested is already there. For example, assuming that we would have a specification that states the following: “a UserGroup has one or more User(s)”, then the test could look like this:

class SomeTest {
[...]
@Test public void testMethod() {
UserGroup ug = new UserGroup();
assertTrue(ug.userCount() > 0); // it should be one or more

We can even expect how many users should be on a newly created UserGroup

assertTrue(ug.userCount()) == 2);

We can now see that the specification is more refined.

Not only that an UserGroup has at least one users when it is newly created, but we can even add more constraints.

for (User u : ug.getUsers()) {
assertTrue( u.getName().equals(“admin”) ||
u.getName().equals(“moderator”)
);
}

And we even know that one of the default users is admin and the other one it is the moderator.
Furthermore, fully check the specification.

ug.removeUser(ug.getUsers().get(0)); // blindly remove the first user
assertTrue(ug.userCount() == 1);
ug.removeUser(ug.getUsers().get(0)); // blindly remove the second user
assertTrue(ug.userCount() == 0);
try {
ug.removeUser(ug.getUsers().get(0)); // remove the first user again
assertTrue(false); // this is unreachable
} catch (RemoveUserException e) {
// ...
}
}

...

At the end of our test, our specification is more clear about what should happen when we create a new UserGroup, how we can access the Users inside (notice that the specification didn't said at all how this should be done), and the obvious thing that the code we just wrote can be used now as a regression test.

As I've said before, this code is written as the code to be tested already exists. What that means in plain English is that the code won't even compile in the first phase. (remember, both of the classes User and UserGroup are not existing at all). For this, it would be a good thing to remove from your IDE the automatically build feature. Otherwise your screen will be cluttered with red lines stating errors which you can safely ignore for now.

Now the test becomes a part of the specification itself, and it should be delivered as such.

There are at least three issues to consider though:

What happens when multiple developers are writing test cases for different parts of the model?
The main problem that can occur in this case is that of two developers messing up the signatures of one object. In our example this could happen if one of the developers would consider that the User's name should be retrieved with getUserName instead of getName. Now there would be two methods with the same role - redundant code and a code that smells like danger.
What if the specification gets changed – either by plain internal refactoring, or the customer changing the requirements?
The tests need to be rewritten. Even if it might look hard in the beginning, they are the guarantee that our model is actually implementing the specification given, and not just a bunch of classes that reminds us of some old, lost inside the Middle Earth since the rise of Sauron, specification.
After the test, it is highly possible that the specification will be altered. Should these changes be published back into the original document?
This is a tricky question, and it all goes down to common sense. For the UserGroup example I think it should update the document by writing explicitly that the UserGroup creates by default 2 users, admin and moderator. It is important to expect this when creating a new UserGroup, and it is part of its contract. All the other changes, like how to access the User name, how to get the list of users from the UserGroup, and such like it, are irrelevant and they will overload the documentation with useless details.

Bottom line
Advantages

We have at least the following guarantees:

The code doesn't break.

The code is functionally correct in all of its use cases.

The code behavior can be verified when change inside the code occurs - extensions or just bug fixing.

It adds value to the developers work by providing clearer requirements and usage scenarios.

Disadvantages

Initially it may look cumbersome to write tests without any class since you don't see any functionality being added to the project.

Changes in the project model (or services) needs to be also reflected into these tests. This may lead to fear to refactoring, even if such a refactoring is much needed, if it would impact a big code base, since the initial code of the tests will be most likely thrown.

You have a new project to take care of (the set of tests is a project in its own right^²).

Appendix

Another place where TDD can be used with success is, in my opinion, when using interfaces of products or modules which are developed in parallel. What happens now, is that we have the interfaces of the other module we want to use, we have their documentation written down, but we have no usage pattern. So we will write some stubs that implement the service we are using, and create the tests for the service. When the actual service is used instead of the stubs, the tests should be passing. Otherwise it means we either had some wrong assumptions regarding the module we just used, either the actual module was delivered with bugs into our side.

1There are methods of doing so directly in the UML (sequence diagrams, for example) but they are hard to draw and hard to be comprehended at a quick look.

2 Even though it doesn't need its own tests, since it would make almost no sense.

The right tool, for the right job, part 1

2007-08-12T18:34:00.000-07:00

Today I am going to speak about programming languages and I will do a quick comparison between bash, perl, python, c++ and java, or as some may like to say dynamic vs strong typed languages.

Many people, especially those exposed to only one operating system, tend to have a limited knowledge about dynamic languages and they are mostly stuck with c++ or java. Even though these languages are great, dynamic languages permit you to do rapid prototyping and to have faster development cycles (since in most of the cases, at the time of writing, the program is already compiled and deployed).

Ok, so let's get it started:

bash
bash is the shell you're most likely already using if you're using a Linux distribution or a Mac. And, if you didn't knew, it's also a programming language. In my opinion this language is perfect for basic maintainance tasks (e.g. removing all backup files from subfolders, and packing the current folder).

It could be written as simple as:

#!/usr/bin/env bash

# find and remove all ending with ~
find . -name \*~ -type f | xargs rm
# archive the current folder into archive.tar.gz
tar -cf - . | gzip > ../archive.tar.gz

Variables are dynamic:

a="foo"
echo "variable a is $a"

perl
perl is the language of choice if you want to do log parsing, applying regular expressions over mountains of text or one way code generators.
For example to implement grep's functionality you need 4 (four) lines of code.

#!/usr/bin/env perl
$search = shift;
while (<>) {
print $_ if (/$search/);
}

Code generators can be done as fast:

#!/usr/bin/env perl
$class = "Foo"
$member = "x"
print <<CPPCONTENT;
// default constructor
${class}::${class}() {
$member = 0;
}

int ${class}::get_${member}() {
return $member;
}

${class}::set_${member}(int value) {
$member = value;
}
CPPCONTENT

And notice that the change will be done in place.

python
Python is perl with steroids. While the regular expressions support and reading into the default $_ is not there (this makes while(<>) { print $_; } so magic in perl) it has all the other goodies of being dynamic, contains libraries for whatever you can think of, and a very strong support for objects. In Python absolutely everything is an object. I don't know another language to have this - eyther they are limited by being strong typed.

#!/usr/bin/env python
h = {}
h['user'] = "BM"
h['title'] = "Mr."
print "Dear %(title)s %(user)s, you are kindly invited to dinner." % h

Guess what it'll print! Yup, you got it right. More or less like perl in this aspect. But the following is fantastic (try it in IDLE, python's default IDE - if you have installed python, you have IDLE):

>>> class A:
pass

>>> A.x = int()
>>> a = A()
>>> dir (a)
['__doc__', '__module__', 'x']

Whoaaa... What just happened here. As I told you, in python everything is an object. Hence, to the class A we added a new member (after the class was defined), after we instantiate a, we can see that x is defined. If you don't belive it's a new member, define a new instance of A and assign it values ;).

Basically, even if you can't extend the primitive types of the language (e.g. add new methods to the str class to better suit you) you still can change the base classes of various frameworks you may use.As you might already have noticed some parts may look enough "cryptic" already, and it's perfectly normal, no need to be scared. The point is that if you diversify the number of languages you know you will finish your work sooner with less work. Imagine doing the bash example of removing all backup files in java and you'll see that it would have taken ages to complete it.

In bash it's exactly one line.

Or the code generation from perl. In how many lines you can do it (except python)? Actually, in perl, you're almost writing the final program. This is why it's the main language I am using when I am developing one way code generators for classes that look mostly the same but have some weird logic that I can't convince my IDE to do it.

Bottom line: no programming language is an island, and there isn't such a language to catch all the needs of millions of programmers out there for the billions of tasks they must make. Diversify your knowledge.

The DRM failure

2007-07-26T17:11:00.000-07:00

Hi again... I haven't wrote in a while because I was quite busy. I am developing something and I hope soon (2-3 months at least) I will be able to announce the project more or less ready.

Today I am going to talk about DRM. What is DRM? Well, DRM stands for Digital Rights Management and is a way for some corporations (usually content providers - a.k.a. multimedia producers, etc.) to control the way you use the media you purchase from them. Allmost all serious music producers are using it in order to distribute their music. What DRM enforces is how you can (not) use your music, on which devices you can copy it and how many times, and so on.

For example, you can't download an MP3 and play it on every USB device? Why? Because that would defeat the purpose of DRM. You would be then able to copy that content to other devices DRM free and eventually share it with your friends.

Basically DRM has only one reason behind it: not to trust you. In theory if you are a pirate it will be very hard for you to distribute the "stolen" music to other peers. In practice if you really want to steal music you have google.com, altavista, and good old bittorrent sites. And because there are so many file sharing sites, the whole purpose of DRM has backfired against regular users who do actually buy music.

For example I buy my music - for some people this may sound crazy, and quite recently I've discovered Seven Places (a very cool true Christian band - or exband more accurately said) and Jeremy Camp (another Christian singer). And I've decided to buy them. Unfortunately I am living in Cyprus and amazon.co.uk doesn't ship in Cyprus. So I decided to buy their songs online.

I couldn't find any shop to sell that song without DRM. Why I explicitly want that? Because I am using Linux and I don't want to switch to a worse operating system because of some trifle reason. Why would I have to give up my liberties (or at least a part of it) because some corporations are incapable to trust me? I don't want to be limited in copying my music just to a few "compatible devices" as they name them or to use Windows XP. After all we pay for those songs, and we should be in charge, demanding what rights we want, not the other way around.

I want to be able to listen my music on my phone, on my mp3 player, burn CDs for my car (eventually, since I don't have a car) and also play them on my PC. Otherwise, online radio, youtube and bittorrent will be my music provider of choice.

Four Freedoms

2007-06-26T10:31:00.000-07:00

I always loved software. Actually the whole process of creating from nothing (bits and bytes) something. Something which you can't possibly touch, but yet is being able to display various shapes and colors, or being able to print and so on.

And to some extent it looks and it behaves "magic". For no apparent reason, it takes sometimes less then a second from the moment you clicked print until the engine from the printer starts working and in the end you have a beautiful picture displayed on a sheet of paper.

But what if I would tell you that at least 7 (seven) protocols were used for that single piece of paper to go from your PC or MAC, to your printer to get printed? You have PS (or PostScript, the language that your printer knows), most likely Physical, Ethernet, IP and TCP (all from ISO/OSI protocol - more or less) to move your image over the network, and your image was most likely GZipped so it would reduce network traffic and was encoded let's say as PNG.

Can you imagine? All this complexity is completely transparent for you. You don't have to know
nothing about it, in order to print your graphic. It's just amazing.

But there is something you must know about it...

It's All Freedom... or Not.

I think anyone should have the following freedoms when it comes to whatever software they use:
1. The freedom to run the program, for any purpose (freedom 0).
2. The freedom to study how the program works, and adapt it to your needs (freedom 1). Access to the source code is a precondition for this.
3. The freedom to redistribute copies so you can help your neighbor (freedom 2).
4. The freedom to improve the program, and release your improvements to the public, so that the whole community benefits. (freedom 3). Access to the source code is a precondition for this.

These are by no means original ideas. These ideas were stated first by Richard Stallman a man who saw a danger in the way that software is done. Actually, these days, the software is done in such a way that it's meant not only not to give freedoms, but to enslave its users. Imagine you will be forced to use only one operating system, or better even, cook only one recipe. Sudden change of subject? Maybe. but here's another quote from Stallman:

Imagine how angry everyone who cooks would be if some day the government says "From now on, if you share or change a recipe, we're going to call you a pirate, we're going to compare you with people who attack ships, and we're going to put you in prison for years because that's forbidden cooperation". Imagine the anger that there would be. That anger is at the basis of the free software movement too. We want to have freedom in using our computers.

It does make sense, isn't it?

Does Freedom Exists?

I dare to present to you, today, the freedom 0 in a very known operating system, Ubuntu:

There it is, right there... the freedom 0. You can take whatever software you want and use it in whatever way you want. No strings attached. As you can see though, freedom it's all about empowering you as final user in being able to choose what software you want, and to be able to share it with your friends.

Unfortunately most systems nowadays are not at all like this. Most likely if you bought them, you can't share them with your friends, you don't have access to the source code (you, or your geeky friends).

Now imagine that there is an Operating System that empowers you with one click in getting the latest free software you can use. I am writing from it, about it. I am creating on it. I am sharing it with you. No restrictions, no boundaries.

Freedom starts here: ubuntu

Fixing vmware for ubuntu.2

2007-06-22T12:33:00.000-07:00

After I've rebooted my machine I've realized that again for some unknown reason the not_configured file it's still in /etc/vmware even if vmware service started successfully. This will give you the following:

vmware is installed, but it has not been (correctly) configured
for this system. To (re-)configure it, invoke the following command:
/usr/bin/vmware-config.pl.

each time you want to run vmware. Even if you do vmware-config until the very infinite, it still won't work and fail each time with the same error. This is a "known bug" - at least by me - and it reduces to the following axiom:

"If and only if vmware services are up and running, and the not_configured file it's still existing in /etc/vmware then you can safely remove it."

While I can not guarantee it, it's a fact for me proven by practice for many-many times before. So I gave it an aid in /etc/rc.local so I won't have to remove it every time. Now my rc.local file contains also:

rm -f /etc/vmware/not_configured

Don't forget, the vmware services should be up and running and only vmware program failing to launch.

You would do anything to stop me using your product, ain't it VMware, ain't it?... eh? Just kidding. As a matter of fact is that VMware Workstation is a great product, since it has very good driver support and hence performance on guest systems, and very less load on the host.

I am quite happy with it running my SVN server.

Fixing vmware for ubuntu

2007-06-20T21:50:00.000-07:00

I've updated to the brand new latest version of Ubuntu, as I like to be in shape with the latest trends when it comes to IT in general, and Ubuntu in special. After I've update my kernel to linux-server-2.6.20.16 suddenly I've realized that vmware wouldn't like to start.

This is a very unfortunate event since on that "machine" I am holding my SVN server... so if it's down, then... no work can be done.

I did like any guy would do in these circumstances:

/usr/bin/vmware-config.pl

but failed with this error:

Using 2.6.x kernel build system.
make: Entering directory `/tmp/vmware-config0/vmmon-only'
make -C /lib/modules/2.6.20-16-generic/build/include/.. SUBDIRS=$PWD SRCROOT=$PWD/. modules
make[1]: Entering directory `/usr/src/linux-headers-2.6.20-16-generic'
CC [M] /tmp/vmware-config0/vmmon-only/linux/driver.o
In file included from /tmp/vmware-config0/vmmon-only/linux/driver.c:80:
/tmp/vmware-config0/vmmon-only/./include/compat_kernel.h:21: error: expected declaration specifiers or ‘...’ before ‘compat_exit’
/tmp/vmware-config0/vmmon-only/./include/compat_kernel.h:21: error: expected declaration specifiers or ‘...’ before ‘exit_code’
/tmp/vmware-config0/vmmon-only/./include/compat_kernel.h:21: warning: type defaults to ‘int’ in declaration of ‘_syscall1’
make[2]: *** [/tmp/vmware-config0/vmmon-only/linux/driver.o] Error 1
make[1]: *** [_module_/tmp/vmware-config0/vmmon-only] Error 2
make[1]: Leaving directory `/usr/src/linux-headers-2.6.20-16-generic'
make: *** [vmmon.ko] Error 2
make: Leaving directory `/tmp/vmware-config0/vmmon-only'
Unable to build the vmmon module.

I took a quick look at the source code and I couldn't possibly find were the compat_exit is defined... and... I've commented the offending line which was also a static symbol, that I don't think it was used anywhere -VMware, take care - (if it was used I would fail at compile time). I've built it and... tadaaa.. it works.

So, here goes my fix... If you are experiencing the same problem, you would need these two files:

	vmware-config.diff
	vmfix.diff

Download them to be located both in the same folder.

Then, you will need as root (or sudo) to patch your vmware-config from /usr/bin like that:

# patch /usr/bin/vmware-config.pl vmware-config.diff

then in the same folder where the files are (especially the vmfix.diff)...

# /usr/bin/vmware-config.pl

... and just sit back and relax.

Here it goes...

2007-06-13T06:43:00.000-07:00

It had begun....