Ubuntu insights, Programming in groovy, java, et als!

Wednesday, February 29, 2012

Bypass the Linux Grub to retrieve Windows Bootloader

Rececntly I had messed up with the Linux partitions on my laptop because of which the grub rescue wasn't letting me login to any of my operating systems. This is a simple step that I came across to bypass the Linux grub to retrieve back my Windows Boot screen back. Simple yet helpful.

1) Insert a Windows 7 upgrade disc.
2) Enter boot menu to boot from CD/DVD.
2) Proceed to repair Windows. (Caution : Do not reinstall Windows)
3) Open command prompt
4) Type in
Bootrec.exe /FixMbr
which reports a quick reply reporting, "operation ended successfully"
5) Remove disc and Reboot from HDD.

Tuesday, February 14, 2012

Coffee with Linux #1 - Head Start


It is often a gigantic task for a newbie to grasp concepts of Linux, not because they seem nerdy but mostly because there are way too many facets to the OS and it is surrounded by a humongous number of other terms which usually tend to scare away a learner in the first glimpse. Most of the time, beginners find it hard to find a starting point to learn Linux. 

Coffee with Linux will be a series of blog posts which will touch base concepts at a very superficial level. The blogposts in this series will usually be the gateways for you to enter into the world of Linux. The series will eventually run into posts that will describe the usage of commands from terminal. The learning will not be in bookish order, it will rather be in the order of the things I learnt/learn/will learn. So let's get started!

Li'l history

Unix was an operating system started as an academic project, pioneered by the likes of  Dennis Ritchie and Ken Thompson, at AT&T's Bell labs during the late 1960s. It gained popularity and different communities and groups were picking up unix and developing their own versions of Unix.  One such version was Minix which was supposedly a minimal Unix version, which was written by Andrew S. Tanenbaum. Minix was used in universities to teach computer science. Linus Torvalds picked it up, contributed to the development of an open source Kernel and called it Linux. 


As Linux is open sourced, anyone can pick up the source code and develop a version of his own. Thousands of distributions have emerged since the last couple of decades. To name a few, Redhat, OpenSuse, Ubuntu, Lubuntu, Kubuntu, Bodhi Linux and TinyCore are some known distros. To know about the different distros of linux, visit  http://distrowatch.com 

Understanding the OS

An operating system typical has three layers. 

Environment (The Top Layer)
This layer in very raw terms deals with applications that interact with the user. Terms like KDE, GNOME and UBUNTU's UNITY fit in here. They are typically the desktop environments and Linux gives the user complete flexibility to use any of these desktop environments. If need be, the user can even chuck out this desktop environment layer and stick to the default command line interface. 

Example to Ring a bell : Desktop themes, icons, toolbars, etc.

Kernel (The Middle Layer)

Kernel is an abstraction layer that co-ordinates the applications with a system's hardware and resources. An operating system exists only because of its kernel which usually takes care of all the OS specific operations like process, memory and device management. It is completely 
written in C and can be downloaded at  http://kernel.org/

Example to Ring a bell : Running two or more applications at a time and multitasking on them.

System Resources (The Lower Layer)

File System, memory and all hardware specific physical matter come under this layer. 

Example to Ring a bell : The presence of a graphic card to play high end games. 

------------ End of tutorial 1 -----------

Thursday, February 02, 2012

The Art of Test Driven Development

For the very for first time, I have dabbled myself into the practices of Test Driven Development. I must admit that I am completely bowled over by the experience. For more than an year, I had been reluctant to adapt the concept of unit tests as I mistook writing them as a programmer's lack of faith in the code he pushes in but I eventually realized that I could NEVER BE MORE wrong.

I have long had this evil habit of quick prototyping where in all I care about is the end result. In this process, what starts off as a script evolves into neatly refactored block closures and methods, methods to classes & objects and classes to packages. In spite of starting to code with a basic design in mind, it becomes very hard to adhere to the architecture and design with this bottom-up approach as it solely aims at achieving a result without considering the means to achieve it. Hence the code quality might short fall of standards as it ought to be. Also, this involves constant rework. Though a quite conventional approach and a pleasure to begin with, this method is bound to inflict pain at later stages when the code base evolves into a dinosaur and becomes hard to maintain.

Test Driven Development on the contrary might seem annoying at the start to code with but eventually pays off. TDD is all about starting to code keeping in mind the unit tests that are going to be written. The core code base and the xunits are written in tandem with each other. They go hand in hand. It appears like programming in two places at a time. You code for a method in the base class and write its corresponding test in the testcase and run it simultaneously. With TDD, it is like thinking in two directions at a time. As a result of coding in tandem with the unit tests, the very initial draft of code itself begins to look like what it would seem to look like after two or three cycles of rework. Very neat, well re-factored, modularized, extensible and testable. The code written in this manner is more reliable because the unit tests enforce the programmer to code keeping in mind the exceptional scenarios, exposing all the permutations and combinations in which a piece of code could behave. As a result of this, the bugs in the final delivery will dwindle down considerably.

The number of unit tests increase over a period of time along with the code. All the testcases written could be run on a periodic basis to ensure that any newly committed code will not break the functionality of the existing code base. This diminishes the scope for regression issues and hence adds to scalability and maintainability of code. 

Very often it becomes difficult for a newbie to get a hang around code that is already written. Even in such cases testcases help because unit tests themselves act as informal documentation to the classes and methods used. Adding to that, as the code grows in size, the need to use a debugger eventually reduces provided the code is covered by diligently written testcases. 

TDD is an elegant art. Practice it! Preach it!, to everyone who aims to be a quality programmer. For, it is a priceless feeling to experience the 'aha' moment when you look at your sexy monstrous code base that says "All tests passed".