cmdematos

Ubuntu 11.10 Oneric on Dell XPS17 L702x (Updated Dec 14 2011)

2011-10-16T00:25:00.001-04:00

The good news is that everything works. My spec is 8Gb, Core i7-2720QM, hybrid dual graphics Optimus technology - HD3000 + NVidia GT550M with dual 640Gb drives and 1920x1080 display.

Now, here is what you need to do to get everything working. Thankfully, its all relatively simple:

Install Ubuntu 11.10 from scratch. My attempts at upgrading in place where not exactly successful. Everything seemed to work, but it was unstable and I began finding things that did not work as well as they should. An fresh install and everything went very smooth indeed.

After the install you will encounter the following issues:

The touchpad stops working a few seconds after you login.
You cant hybernate or suspend and shutdowns may hang.
OpenGL Graphics do not work, you may be prompted to install nvidia drivers (dont do it, it is the kiss of death).

Its very simple to fix all of the above.

Fix the touchpad by changing turning off the 'Disable touchpad while typing' option. While you are there, turn on two finger scrolling and horizontal scrolling. The Synaptics touchpad hardware and the Linux multi-touch implementation is as good as the Apples.

The issue with the shutdown, hibernation and suspension is an issue with the USB3 driver. To work around it, insert a file into /etc/pm/config.d (I called mine 'XPS17-custom') with the following content:

SUSPEND_MODULES="$SUSPEND_MODULES xhci-hcd ehci-hcd xhci_hcd ehci_hcd"

To fix the OpenGL graphics and to enable the use of both Graphics adapters, install mesa-utils, driconf and Bumblebee. There are several distributions out there for both Bumblebee and an offshoot project called IronHide. Dont use any of the distributions from Github, instead carefully follow the instructions on the stable Ubuntu Bumblebee Project.

Follow these steps ...

Install mesa-utils and driconf...

$ sudo apt-get install mesa-utils driconf

When selecting the profile to install, if you are unsure which to use, use mine. There is one called 'cmdematos'. If you are happy with it, confirm it to increase confidence in others as well.

Published in the hope that this helps you towards a smooth installation experience!

[Edit 10/17/2011] - I am using an Intel Centrino Advanced-N 6230 with built-in Bluetooth and experience no problems with it whatsoever. Some earlier Intel wireless cards have reported having issues suspending and waking up. These issues are supposedly corrected as of kernel 3.0.0-8.11.

If you experiencing issues with your suspend/hibernate, try adding the following to a file in /etc/pm/config.d/intel-wireless.

SUSPEND_MODULES="$SUSPEND_MODULES iwlagn"

Ubuntu Oneiric 11.10 Touchpad issues

2011-10-14T09:01:00.001-04:00

I ran into issues using Ubuntu 11.10 on a Dell XPS 17 (L702x). The touchpad worked during the live USB test drive but stopped after a few seconds post-installation, It seems that the touchpad is not re-enabling itself after typing if you have the 'Disable touchpad while typing' turned on, which is the default by the way.

To fix the issue, simply disable the 'Disable touchpad while typing' setting mouse/touchpad setting.

Another fix for this involves the installation of the 'synaptiks' package. Simply search 'touchpad' in the Ubuntu Software Center. However, I don't recommend that you do this. This is not a package that is needed to control your touchpad. It does not add any extra useful functionality and it drags in a lot of KDE specific QT4 libraries that you would not otherwise need. Instead, my recommendation is that you disable the 'Disable touchpad while typing' option in your touchpad configuration as shown here.

The philosophy that works for me is to keep the installation on your Linux as systems as standard as possible. I avoid getting distribution source from 'edger' PPA's and getting ahead of the distribution as far as possible, preferring to wait for the for fix to arrive, which it always seems to do so within just a short amount of time. After all, this is Linux, ever changing and never finished, and Ubuntu has 2 major releases a year. Quite an accomplishment.

SOLID Code Avoids Boolean Parameters

2011-10-06T21:23:00.000-04:00

With an example of how this would make disposing of resources easier…
According to Uncle Bob's principles, most of which I agree with, passing Boolean parameters is something to be avoided. To understand why you first need to agree with the Single Responsibility Principle (SRP).
The Single Responsibility Principle (SRP) states that there should be one and only one reason for a class to change. It follows therefore that methods within such a class should perform one responsibility only.
Readers should note that this is a Principle (guideline) and not a Rule. This distinction is often not made by those who choose to criticize this principle. It follows that the only appropriate criticism for a Principle, is an opposing principle and not one or a set of edge cases where logic may lead one to overrule a Principle. A suitable argument against SRP would be along the lines of ... ' a class does not deserve to be a class unless it has more than one responsibility' - a Multi-Responsibility Principle (MRP) if you will. It certainly cannot follow that as a Principle that both SRP classes and MRP classes are equally correct.
If after some consideration you decide to agree and abide by this principle you will find that it is improbable that you could build a method that receives a boolean parameter that does not violate this principle. For example
CALL DoThis (WithThisData, WithThisBoolean)...
PROCEDURE DoThis (WithThisData, WithThisCondition)
BEGIN
   IF (WithThisConditionIsTrue)
        <do some stuff which amounts to responsibility1 WithThisData>
   ELSE
        <do some stuff which amounts to responsibility2 WithThisData>
END
Instead the pseudocode above should be ...
   IF (WithThisConditionIsTrue)
        DoResponsibility1 (WithThisData)
   ELSE
        DoResponsibility2 (WithThisData)
PROCEDURE DoResponsibility1 (WithThisData)
...
PROCEDURE DoResponsibility2 (WithThisData)
....
Uncle Bob writes ...

F3: Flag Arguments
Boolean arguments loudly declare that the function does more than one thing. They are confusing and should be eliminated.

Another reason why I like this principle is that according to my philosophy on the reasons why we write code (summarized by the simple answer: so that others can read it!) is that it is almost always harder to understand the intent of a function that receives a flag (boolean) argument.
It follows therefore that our well published C# IDisposable pattern is not SOLID code because it uses a boolean argument. The pattern is not as widely used as it should be and many people incorrectly publish that the pattern does nothing useful. I blame part of the confusion and differing opinions on this one tiny flag passed into the Dispose(true) call.
I wont go into explaining the pattern itself, but let me explain that it looks like this...

        public class BothType: IDisposable{
            public void Dispose(){
                Dispose(true);
                GC.SupressFinalize(this);
            }

            ~BothType(){  //finalizer
            Dispose(false);
        }

        protected virtual void Dispose(bool disposing){
            if(disposing){
                //'Disposable' managed resource cleanup code
            }
            //Unmanaged resource cleanup code
            base.Dispose(disposing);
        }

Managed code developers (Java, Dot.Net, PHP, Python, Ruby etc) are abstracted from most memory and resource management concerns, and in most applications ignoring even the attention required by the small number of unmanaged resource that are allocated and never properly released is uneventful because our modern machinery is grossly over-spec. But this behavior fails quickly in a stressed server environment where resources are always under pressure.
The pattern above ensures that if the code did not dispose of unmanaged resources by the time the wrapping managed code is Garbage Collected then at least the finalizer frees the unmanaged resources. Of all the explanations that can be found online, most people do not focus on this above reason which is the reason for the pattern to exist in the first place. You will find all manner of interesting chatter, from the fact that Dispose is not called by the Garbage Collector to the fact that the presence of a Finalizer causes your class to survive at least one Garbage Collection attempt (usually followed by the incorrect advise to never create the finalizer). But not many people focus on this one reason why the Dispose pattern exists – which is to attempt to free unmanaged resources before Garbage Collection takes place or to at least catch unreleased resources at the last possible moment and release them then.
The correct pattern does this:

If your class encapsulates unmanaged resources it must ensure that these resources are released by calling Dispose(). The Dot.Net framework standard method to accomplish this is the IDiposable interface.
It follows that Disposing of a classes resources should cause that class to call Dispose on all its encapsulated classes and its base class as well if these implement IDisposable.
You (the developer) must ensure IDisposable.Dispose is called when the class is no longer needed.
Dispose must be allow itself to be called multiple times.
Dispose must release the classes own UnManaged resources.
Dispose must then suppress the classes Finalizer by calling GC.SupressFinalize(this)
The Finalizer should contain code that does nothing more than release the classes own unmanaged resources. It is not expected to be called since Dispose should suppress its calling. However, it is a belt and braces approach, defensive coding if you will.

Now, how much of the above did you get from the code snippet? Unfortunately the pattern is setup as is and its too late to change its implementation. The Dispose(boolean disposing) method is meant to be inherited, virtually overridden and called by base.Dispose(disposing) to chain the release of resource request down to parent classes.
A pity. I think the following communicates the code intent in a much better fashion...

    
        #region IDiposable

        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        public void Dispose()
        {
            DisposeManaged();
            DisposeUnManaged();
            GC.SuppressFinalize(this);
        }
        
        /// <summary>
        /// Calls Dispose() on all our managed resources
        /// </summary>
        private void DisposeManaged()
        {
            this.SomeClassA.Dispose();
            this.SomeClassB.Dispose();
        }

        /// <summary>               
        /// Disposes our unmanaged resources
        /// </summary>
        private void DisposeUnManaged()
        {
            this._managedResourceA.Close();
            this._managedResourceB.Free();
        }


        ~ABetterDisposerPattern()
        {
            DisposeUnManaged();
        }


        #endregion IDisposable

The above accomplishes everything that the traditional IDispose pattern accomplishes - and look! It does it with clarity of intent and far easier legibility, don't you think?.

Out of memory error in Eclipse

2011-10-03T22:39:00.001-04:00

If you use sun's JVM along with Eclipse you will undoubtably run into memory issues, especially if you run JBoss tools or WTP.

So lets get real here, even at 3rd world 'cheap genius' rates it can be shown that in a matter or just a few hours you can recover the cost of 4Gb of Ram. At time of writting in the USA 8Gb of Ram for a laptop (using DD3 SoDIMS) will set you back less than $45.

The default memory setting for Eclipse are absurd, the heap memory starts at 40mb and maxes out at 256mb. All you need to do is to set the maximum to any value that is reasonable for your environment. For a modern development workstation which should be equipped with at least 4gb of RAM you should be comfortable setting the maximum at least at 512mb if not 2gb. I run 8gb RAM, so I am more than happy to set the value to 2gb.

Now, keep in mind that Eclipse is not going to use 2gb, or rather it is very unlikely that will ever occur, and if it does it most probably points to a bug somewhere. After all, its happy to do its thing most of the time with a maximum of just 256mb right? This is just the maximum value. In a multi-generational garbage collection environment, you will not use this much memory as the trigger for garbage collections is generally the act of extending memory - which occurs only when you run out of memory. The pattern therefore is ...

1. Request some memory
2. Fail to satisfy this memory request
3. Invoke Garbage Collector
4. Repeat attempt at memory request
5. If this fails to satisfy the request, increase memory

The above can be considered 'paraphrased and simplified' and is meant to assist in the conceptual understanding of what is going on when the JVM requests more physical memory to add to its heap. At each major release of the JVM the details and rules surrounding Garbage Collection and memory allocation change a little as the authors try to improve the balance between memory consumption and performance. Its never too productive to know the details of the Garbage collection too intimately, lest we design our code too reliant on a specific algorithm. However, you can rely on the knowledge that many very intelligent developers have and will continue to strive to ensure the best balance between memory and performance. All of this means that you are very safe in increasing your maximums well beyond the default settings.

To fix your issue, edit the Eclipse.ini file found in your Eclipse distribution. Mine looks like this...

Dealing with corrupted CD Drivers in Windows

2011-09-29T12:06:00.001-04:00

This has happened to me a couple of times. I have spent a lot of time trying to fix issues caused by damaged CD drivers on windows. Since this wasted time eats at development productivity, this article is intended to assist developers (or administrators) to fix this issue if they have it. Bookmark this blog entry if you don’t have it, you never know when it will happen to you and this may save you time in the future.

Windows does not have a native means of mounting .ISO files or other CD images. I don’t think that prior sentence does justice to the full weight of the intended communication, so let me try again.

The primary, commercial, expensive, professional Operating System that is Microsoft Windows, includes no means to mount a CD image. After paying for your operating system, the consumer is expected to purchase and/or download third party software to be able to perform this mundane operation.

I cannot think of any other Operating System shipping a decade into the 21st century that is this archaic. I use Magic/Disk to mount my images, but now and again I lose all access to my CD drives, both physical or virtual, especially if I do something crazy with the OS image – like migrate it from physical to virtual, or change the underlying virtualization platform from one thing to another (e.g.: from VirtualBox to VMware or KVM). This also seems to happen from time to time after I upgrade something, anything – OS, Magic/ISO or Virtual Machine client utilities. When this loss of CD Drives happens it is almost impossible to reset things. Uninstalling and reinstalling any manner of utilities and or drivers simply does not seem to help. Next you will be tempted to begin editing the registry – don’t do it.

I ran across a simple solution that I have used on at least three occasions successfully. Simply download and execute the attached .reg file. It contains registry settings that reset the CD Drivers to standard configurations. It has never failed to reset the sanity in my systems.

If you think this is all a bit risky you are correct. You were forced into this risky position when you were forced to begin adding third party software just to be able to mount media images on your ‘21st century’ operating system. Blaming the quality of the 3rd party drivers is putting the blame in the wrong place. OSX and Linux are both orders of magnitude cheaper than Windows, with far smaller numbers of users than Windows, and far smaller number of developers building the product. Yet, both Linux and OSX manage this without fuss. I certainly hope Windows 8 fixes this.

May this be useful to you.

Windows Git Environment

2011-09-16T14:59:00.001-04:00

This article describes the installation and configuration of Git on Windows and its primary audience is intended to be Developers wanting to get a setup a local Git installation to get up and running quickly on Windows. The following is covered:

Installing Git on Windows (5 min)
Installing Visual Studio and Monodevelop integration into Git (5 min)
Installing Windows Explorer integration into Git (0 min)
Installing CLR Bindings for development against Git repositories (10 minutes)

The article does not compare and contrast different Git software tools, it simply records the results of my investigations into the available toolset. The article may change from time to time and will not be supplanted by a new post, instead this post will be edited to reflect my latest Stack and Environment choices for Git on Windows.

Installing Git on Windows with Explorer Integration

TortoiseGit is my choice for Windows Git integration. It provides Windows Explorer integration into Git commands. However, since I prefer to work with a CLI interface and am familiar with Git, I also install Gits own installation for windows. If you install both you should be careful to select whether you want Windows Explorer context menus for Git since TortoiseGit already provides these for you.

Being far more comfortable with Unix command line tools I welcome the option to expose some Unix style CLI commands ahead of Windows find.exe and sort.exe (which I never use – do you?)

The next option is very important if you are building cross-platform applications. Yes – absolutely check “keep my repositories as Unix style text delimiters and automatically convert to Windows style text delimiters when checking out to windows”. Please think carefully through whether this option is good for you. It is not suitable for you if you check in non-binary files, and may not be suitable for formatted text either. If you are unsure your option is Checkout as-is, commit as-is.

Complete the installation and we are set!

Installing Visual Studio Git Integration

There are several options here, all good work equally well. If like me you only use VS2010 by default, go Tools->Extension Manager->(search for: Git). Install. Done.

Installing Monodevelop Git Integration

Done. It’s the standard Source Code provider for Monodevelop. There is no action to take here!

Installing CLR / C# Bindings for development against Git Repositories

Apparently, libgit2sharp ‘has a lot of promise’ so I am keeping an eye on it. At time of this writing though, it is too immature and relies too heavily on knowledge of the Git API for documentation. Its simply not good enough for my needs at this time.
You can find it here. From your project directory, git it from https://github.com/libgit2/libgit2sharp.git.
‘git clone https://github.com/libgit2/libgit2sharp.git’
I recommend the use of GitSharp instead. It is feature complete, has comparatively better documentation and seems to be used in more projects. GitSharp is no longer in active development, the GitSharp team is likewise watching libgit2sharp, believing that it is a superior approach to implementing a set of CLR bindings.
GitSharp documentation is available.Git the source code via...
‘git clone https://github.com/henon/GitSharp.git’
Get the Demo Project here.

Windows Subversion Environment

2011-09-16T11:55:00.001-04:00

This articles describes the installation and configuration of SubVersion on Windows and its primary audience is intended to be developers wanting to build a local SubVersion development environment and covers:

Installing Subversion on a Windows Server (5 min)
Installing Visual Studio and Monodevelop integration into Subversion (5 min)
Installing Windows Explorer integration into Subversion (5 min)
Installing CLR Bindings for development against Subversion (10 min)

The article does not compare and contrast the various tool choices available, but it does record the results of my analysis into the tool-set available. This blog post will not be deprecated if my choices change, instead it will be updated in place so you are safe in linking to it if you simply want to benefit from my efforts.

Subversion Installation on Windows

How to get a local developer Subversion installation, and configure bindings to begin integration of your code projects into Subversion.
There are many options for installing Subversion on Windows. Being a Unix application, subversion does not have a good Windows installation experience. But, being an Apache V2.0 license, third parties are welcome to integrate the product into their own products and some have done a wonderful job of it. On Windows I always use VisualSvnServer because it has everything I need and I can set it up in 5 minutes.

Install from here
I recommend enabling Windows Account integration unless you are setting up a server that you want to share with Linux and OSX machines.

The post installation result is satisfyingly familiar interface that will have you productive in no time.

Integration into Visual Studio

For Visual Studio integration I use AnkhSVN. There are other options including onefrom the makers of VisualSVNServer, but these are not free and my requirements include price and functionality. AnkhSVN works as well as any other Microsoft supplied Version Control client so I have never looked at the for-pay products largely because I never had the need.
After installation you will need to startup Visual Studio and select the Source Control Provider (Tools->Options…) …

Integrate into Monodevelop

I use Monodevelop for cross-platform CLR development. Its useful to have a Windows installation with Monodevelop. By default it installs with Git support, to add subversion to to Tools->Add-in Manager->Gallery.

Integration into Windows Shell

Windows Shell integration is required unless you enjoy command line interfaces. The broad consensus is that TortoiseSvn is the best client to use.

Integrate C# / CLR Applications into Subversion

SharpSvn by the makers of AnkhSvn is the library to use for CLR Subversion integration. There are a large number of well respected commercial and free projects using it which gives the library the credentials we want. As usual, it meets the price (free) and functional requirements.
You need to know the version of SubVersion you installed when you installed VisualSvnServer. The version installed circa 9-15-11 is 1.6.9. To make sure, open a command prompt and enter ‘svn –-version’.
Download and extract the SharpSvn libraries into your project folder. There are two downloads, be sure to get the correct libraries as the these contain both managed and unmanaged libraries which means you need to be architecture aware (x64 v.s. ia32).
Documentation is online and comprehensive and you can find it here...

But you will need more than that. The documentation is not entirely complete and the downloads lack useful examples, unit tests or sample projects. To get these items you will need to get the source hive and peruse through it.
This page gets you the latest command to check out SharpSvn.
‘svn checkout http://sharpsvn.open.collab.net/svn/sharpsvn/trunk SharpSvn-Source --username guest’
The folder SharpSvn-Source\src\SharpSvn.Tests contains our useful examples, easily referenced by operation type.

Its Alive! ~ Why I cant escape Windows…

2011-09-07T12:07:00.001-04:00

Microsoft Windows! You just cant escape it! I run my computing life 85% on Linux and 10% on Mac OSX. Yes, you guessed correctly where the other 5% goes to. I am writing this entry on Windows Live Writer on a VM, because there is nothing better to post a quick blog entry with, no product even comes close in my opinion.

But what does this mean for my personal computing strategy? Nothing, actually. It re-enforces the fact that personal choice and pragmatism rule. I choose my eclectic mix to accomplish my goals, and others have different choices.

I reserve the right to switch platforms at the slightest change in personal preference. There is no Operating System Religion here. I am not technology agnostic, I am instead a technical atheist. In my choice of OS I am strictly a fit-for-purpose person, my purposes change and at the same time the OS’s change.