The ByteBaker

Ubuntu and desktop Linux have come a long way in the past few years. Ubuntu is currently one of the most popular, if not the most popular distro for desktop linux users. It was my first distro and though I no longer use it, I’ve always acknowledged to be a well-polished piece of work and I always recommend it to people who are just starting on their personal Linux journey. Like most other things in computers, getting used to a new operating system is made easier if there is a good source of documentation available. Beginning Ubuntu Linux, published by Apress is a particularly good example of documentation geared towards to the new user. I’ve reviewed the previous versions of the book and I find that the books have kept improving just Ubuntu itself.

One of the things that makes this book particularly appealing for me is that it starts out with a brief but informative review of the philosophy and history surrounding Linux and Ubuntu. I personally believe (and I think that many other Linux users share this) that there is much more to Linux and open source software than simple technical excellence. It is a way of thinking and acting that I find very appealing and which I wish others to understand. This book does its part in helping new users understand the culture that gave rise to the software that they will soon be using.

The book continues the practice of understanding that most of the people reading it will be Windows users. As a result the chapters dealing with installation also tell users how to properly back up their data and how to smoothen the transition. The guide through the actual installation process is also very in-depth and well written. Partitioning is often the most confusing part of the installation for a new user. I’m glad to see that partitioning has been dealt with very well with all the options in the install process carefully explained and the pros and cons weighed carefully. The chapter dealing with common installation problems is as good as before but now includes information on more than just installation problems. I particularly liked the section on how to deal with resolution and other common graphics problems since these can be very frustrating if not dealt with properly.

Once installation is complete the book goes on to describe with an equal amount of care how to perform various day to day tasks and how to customize your system. The section that deals with Linux equivalents is also comes in very handy for new users who just want to be pointed quickly in the right direction. The book geos beyond describing simply the core operating system and the user interfaces. Of particular note are the sections devoted to how to use multimedia systems. You’d be hard-pressed to find a computer user who doesn’t have a substantial collection of various music and video files and this book helps newbies get up and running with minimal effort. This new edition keeps the sections on using OpenOffice and the BASH shell but adds substantial material regarding the new automatic multimedia setup, the 3D graphics effects that have the Ubuntu desktop much more visually appealing and also on security and encryption. There is also a mini-tutorial on using the GIMP for basic image manipulation which I think shutterbugs will find handy.

The last part of the book is devoted to slightly more advanced topics such as package management, backups and automation and remote access. Personally I feel that package management deserves a more central place, right alongside installation, but the book’s modular structure means that this isn’t much of a problem. Overall the last few chapters act as a springboard from where newbies can start another journey to the level of power user and beyond.

The book as a whole is well laid out and material is clearly separated. The use of sidebars and small tips and warning sections means that a good amount of extra information is presented without interrupting the main flow of the text. There are also lots of links to other information sources where the interested reader can go to for more in-depth information. Most of these are freely available online sources and the full URL is often provided resulting in minimum effort for the reader. For Windows and Mac OS X users there are also pointers to third party tools that might make migration easier. The book is replete with high-quality black-and-white screenshots which add to the complete guide experience that the book provides. The third edition updates everything to be in sync with Ubuntu 8.04 and comes with a double-sided DVD containing a ready-to-install image on one side and various ISO images of the Ubuntu derivatives on the other. In essence the book has everything that a user would need to get up and running with Ubuntu.

The book is at a reasonable price of $39.99 and I think it’s a good investment for anyone looking to jump into the world of Linux. Even though you’ll get the most from this book in the first few weeks after installing Ubuntu for the first time, the later parts of the book will serve as a handy quick reference for those types you find yourself needing to dig under the hood. There is certainly a large amount of information online which means that books of this type are not strictly necessary, but at the same time it can make things a lot easier to have a quick reference close at hand. My litmus test for this sort of this sort of product is generally: would I give it to my mom? This time the answer is yes.

Since I have some three months before I start my computer science course at college, I decided that I’d get a head start and learn some real computer science (not just programming) before I get started. Though I’ve dabbled with a number of programming languages (and have a number of “beginning” books thanks to Apress publishers) they really aren’t good for computer science per se. I’ve decided to go with a long-standing computer science classic: Structure and Implementation of Computer Programs.

The book has been the textbook for MIT’s introductory computer science course for over two decades and has a wide reputation. One of the reasons that it has been regarded as a classic is that it doesn’t use any “industry standard” programming language at all. Rather it uses Scheme, a dialect of LISP, a functional programming language and one of the oldest to still be in active use. Scheme is extremely well-suited to be a “learner’s language” for serious computer scientists and it’s hard to actively use Scheme without being deeply impressed by it. Even though I have only been using Scheme for a few days, I’m already in love with it and though it isn’t quite my favorite programming language, I really enjoy using it, much more than most of the other languages I’ve used before. Here’s why:

Scheme has very little syntax

One of the things that makes Scheme stand out from most other common programming languages is that it is a functional programming language with very little actual syntax. All the code that you write is part of a function and your program works as a series of interactions between these functions. Not only are there no classes, or objects, there are not even the more common syntactic forms such as loops (while, for, do-while etc.), these are implemented via function recursion. In fact, besides the function definitions, the only major syntax students have to deal with are conditional statements in the form of an if-else idiom and a general conditional syntax with multiple conditions and corresponding actions, such as:

(cond

(test1 expr1 ...)
(test2 expr2 …)
…
(else exprn))


Though there are an abundance of data types, students do not really have to bother about these when they get started. All this means that any intelligent student can grasp the fundamentals of the language within a few hours and concentrate on actually learning computer science concepts and their implementations.

Scheme has a great IDE

… in the form of Dr Scheme. Though not really necessary to use Scheme, this IDE makes it very easy to get down and dirty with Scheme. Not only does it offer several implementations of the language (so it’s useful for a wide variety of CS courses), it let’s you immediately run and test code that you’re written. The standard window features both a text area for you to write your function definitions and an interactive interpreter right below it where you can directly use your functions.Along with that there are also simple debugging tools which let you step through your program to find out what’s wrong. Here’s a screenshot to show you what I mean.

Scheme really isn’t a language at all

Many programming languages are created because some people somewhere want a better way to get something done. For Scheme, however the story is a bit different. Scheme has it’s basis in mathematics and in fundamental theories regarding programming language implementation. As a result Scheme is not bound by arbitrary standards or needs to get it to work like other people expect it to. In Scheme, all the code is written in the form of S-expressions, a type of mathematical expression. Add to this it’s complete lack of syntactic sugar and the fact that it’s implementation is based on the theories of lambda calculus, and you end up with something that feels more like a slightly peculiar way to organize your logical thoughts rather another programming language. I personally have come to view Scheme as a sort of “executable pseudocode”. I find that once I’ve come up with an appropriate algorithm to solve a problem, it takes almost no effort to put it into code. This is far from the experience I’ve had with languages like C++ and Java where coming up with running code can be as cumbersome as getting a working algorithm.

Scheme fundamentally changes the way you think

Ask anybody who has worked with Scheme or any other LISP derivative for a considerable length of time, and you’ll probably hear the same thing. Scheme encourages you to put aside the implementation details of a program and concentrate on finding the optimal solution. It’s use of S-expression syntax and functional nature helps you learn to properly segregate the different aspects of a problem instead of letting you cobble everything together. Use Scheme for long enough and you’ll find your Scheme-oriented thinking spill over into other aspects of your life (like wanting to use brackets all the time (and put brackets inside brackets (which is probably something you’ve never done before))). If you haven’t used Scheme yourself, you may not quite have believed everything that you’ve read now, which is actually more evidence for the fact that Scheme changes your thought patterns. If you have a few days worth of time on your hands, go get Dr Scheme and some good Scheme documentation and dig in.

There are a large number of different operating systems out there, including everything from expensive, industrial strength systems to small hobbyist projects. If you’re a computer user, you’re bound to find something out there that you can put to use. But what if you aren’t just a user or even a hobbyist? What if you are a serious computer science student interested in knowing what makes an operating system tick? While there a large number of excellent books on the subject, the best way to learn (as with most things related to computers) is to do it yourself. But writing a whole operating system, or even the kernel by yourself isn’t an easy thing to do, especially if you’re starting from scratch. Most programmers will agree that a very good way to learn programming, any sort of programming, is to read other people’s code, understand what makes it ticks, and then use some of those principles in your own projects. This isn’t hard for small pieces of software, but an operating system, even the kernel, isn’t a small piece of software. Most of the kernels out there, even the smaller ones are rather complicated pieces of code. They’ve probably been in development for years, with large groups of people contributing lots of different code. If you’re new to kernel development, looking at the Linux or BSD kernels probably isn’t a good way to start learning. So what do you do?

Enter Minix. Minix is a UNIX clone, but it has been made with students in mind. Minix 1 and 2 were made by Andrew Tanenbaum exclusively for students to  go along with his book: Operating Systems: Design and Implementation. Minix 3, is still geared towards students, but is also being made usable as a day-to-day system for low resource computers. What makes Minix3 good for students is that it is compact. The whole of the kernel (it uses a microkernel design) fits into just 4000 lines of executable code. The rest of the system runs in user mode, and in case you want to take a look at those parts too, you can do so just as easily. Minix has a fully modularized design, which means that you can tinker with one small part without having to worry too much about breaking everything else.

Even though Minix is for students, doesn’t mean that is unusable as a proper operating system. Over 400 UNIX programs have been ported including a graphical X window system and networking capabilities using TCP/IP. As for programmers, there is a native C compiler and the shell, ash supports scripting. There are also interpreters for BASIC, Perl and Python (though the Python interpreter is very out of date). That should be enough to let you tinker around and learn something useful. While you’re at it, you might want to get the book as well, especially if you don’t know anything about operating systems.

However if you want something that is still in the early stages of development, but has a clear game plan, you might want to take a look at Fiwix, a project geared towards producing a kernel compatible with Linux while keeping students in mind. Like I said, it’s in its early stages so you could learn a lot if you hang around. The Google Directory on operating systems has a few listings for educational operating systems, and some of the might be worth taking a look at. But please do not jump into the world of operating systems without an adequate knowledge of C/C++ and a good grounding in operating system theory or you might find out that you bit of more than you can chew.

    The latest version of Ubuntu Linux, 7.04 Feisty Fawn was released yesterday and at the same time a courier showed up at my door with a package from Apress Publishers. The package contained their wonderful Beginning Ubuntu Linux book, now in its second edition. When I reviewed the first edition, almost a year ago, I liked it a lot. The second edition is also geared to the newbie, just like the first one, but there are a number of changes, all of which for the better.

First off, the book comes with a double sided DVD containing both the 6.06 and 6.10 releases of Ubuntu, Kubuntu, Xubuntu and Edubuntu, which means that there is something for everyone. The basic chapter is the same, starting with an introduction to what Linux is and what you can do with and progressing to how to get around to installing and using Ubuntu. But some sections of the text have been reorganized and additional matter added. Of course, everything is now up-to-date with regards to the 6.10 release. There are more screenshots, which is always a good thing for a new Linux user.

The installation guide is still written in a hold-your-hand manner, something that is certain to be reassuring to people installing their first Linux. The section dealing with common installation problems and their fixes has been expanded and the typesetting is now much clearer, making it easier to find the problem that you are looking for. The getting-started sections as well the introductions to common programs retain their well-written style but have been improved by adding further screenshots and by providing howtos for  common tasks.

One thing that I especially liked about the first edition was the section on using the BASH shell to perform slightly more advanced tasks. The corresponding section of the new edition provides much of the same information, but advanced topics are better explained. The chapter regarding filesystems, users and file permissions has been improved and expanded. This will be a welcome change for first-time users as file permissions can often be something quite hard to understand and quite easy to misuse.

By far the section that has received the most attention is the one regarding software management. There are instructions on keeping your system up-to-date as usual, but also guides on installing an anti-virus software (which is probably not necessary, but many people feel safer with one around) and also on adding more repositories. This is handy for people who are ready to pass out of the “newbie” stage and move on to do some exploring.

On the whole, the book lives up to its claim of being “Written for newcomers to Linux, yet comprehensive enough to appeal to even seasoned users”. While readers will derive the most benefit in the first few weeks of their Ubuntu experience, there is a good chance that you will you be looking up some of the more advanced matter even after a good few months. The second edition has the same price as the first one : $39.99, but whereas the first one was a fair deal, the new one, with all the new material and the power-packed DVD, is a downright bargain. If you’re looking for your first Linux experience, but unsure where to start, I recommend you pick up this book.

Being a student myself, I have to use the Internet regularly for things like projects, papers and sometimes just looking for new things to do. Here’s a list of online services that will make your life as a student easier.

1. Mozilla Firefox Web Browser

If the internet is going to be a friendly companion, you’re going to need this. Standards compliant, feature-rich and most importantly, extensible. Opera comes in at a close second, but there a number of web services that still don’t work properly in Opera.

2. Gmail

The best webmail service on the internet. Not only does it have the largest inbox, it has the best spam filter I’ve seen and it’s use of filters and labels makes it a snap to keep your mail organized. If your working on a collaborative project, and documents that you’re emailed can be opened, edited and saved using Google Docs. Furthermore, using tools like Gspace or Gmail Drive, you can turn your 2 GB of inbox into an online file storage system. But that’s not the end of Gmail’s capabilities, here’s an article about using Gmail to do everything from storing bookmarks to managing your schedule.

3. Online Office Apps — Zoho

Zoho provides a wide-range of online, free office applications including a word processor, a spreadsheet program, presentation creator, a wiki and a planning tool that can come in very handy. Zoho provides a one-stop shop for almost all of a student’s needs. Everything can be stored online, shared with other Zoho users and exported to a number of formats including both Microsoft and OpenDocument formats. Zoho has recently tied up with a number of online storage providers, including OmniDrive, Box.net and myDataBus. Any documents stored in these services can be edited using Zoho’s tools and stored back, without requiring you to download a copy. Unfortunately there is no way to open email attachments with Zoho (at least not if you use Gmail). If integration with your Gmail account is a must, you might want to take a look at Google Docs and Spreadsheets, but it is an inferior product.

4. Google Search

Google Search can be an extremely powerful tool for online research. Unfortunately, most students simply don’t know how to use it properly and as a result, they often don’t find what they’re looking for. If you intend to make your use of Google more efficient, you’re going to need to learn some hacks. Google has a cheat sheet of simple operators and there is an interactive tutorial to help you learn more. And if you’re really determined to become a powerful Google Hacker, get the book from O’Reilly.

5. Google Notebook

This is just what it sounds like: a notebook. You can create a notebook and by using a browser plugin, you can select almost anything off the internet and save it to your notebook. The URL your information came from also gets saved which makes things a lot easier when it’s time to write references. You can reorganize your notes, add or delete them, or move them to another notebook. Once your research is done, you can export your Notebook to Google Docs, which means that you get a skeleton document to start off with (and a lot less copy/pasting). Sharing and searching is also supported, but the search is rather basic.

Clipmarks offers a similar service, and its plugin makes it somewhat easier to add content, but I feel the interface is unnecessarily cluttered and it provides more emphasis on sharing your information. And there is no export feature. Zoho is also working on it’s own Notebook product which should be out soon and from the demo video it looks like it’s going to be a killer app as well.

6. Online Calendars and To-do-lists

You won’t be much of a student if you don’t manage your time properly luckily the internet is there to help you out. There are a number of online calendars out there, out of which Google Calendar is the one I like. But 30Boxes is a strong contender and there are a number of people who swear by it.

While talking about to-do-lists, Remember the Milk beats them all. It’s simple, uncluttered and gets straight to the point. It’s also easy to integrate it into Google Calendar, giving you an all in one time management tool. If you want a heavier management system, you might want to look at Backpack, though its calendar is only in the non-free version.

Many of the above aren’t as feature-rich as their desktop equivalents, but that will probably not be a problem for most students. And of course all that is balanced by the fact that your data is available anywhere, anytime (as long as you have an internet connection). It takes some effort juggling multiple services, but if you invest some time in learning your way around, you’ll get better benefits in the long run. If you have your own can’t-live-without web services, do tell me and I might include it in a future update.

I’ve recently started learning progrmming seriously and so I’ve been on the lookout for good books to learn from. So here’s a short list of books that I’ve found useful. They deal with a variety of languages and concepts and the best thing is that they’re all absolutely free. Please note that these books would probably be most useful for someone in the last two years of school, though older people shouldn’t have a problem. I’m personally using them as a sort of prep for studying Computer Science in college and so only time will tell if I’ve been successful.

How to Think Like a Computer Scientist - Python Version

Python by itself is a very good programming language for beginners (unless you’re less than ten years old in which case I would suggest Logo). Combine that with a good book and you get a winning combination. The book’s style is clear and cluttered and the chapters are fairly self-contained. It does a good job of introducing procedural programming first before moving on to object orientation (which can be quite a difficult concept for beginners). My only real gripe is that there seem to be too few exercises, which sort of leaves you on your own to find something to do.

How to Think Like a Computer Scientist - Java Version

This is the original Think Like a Computer Scientist book, and unfortunately it’s one major flaw isn’t really something that can be fixed: the choice of language. Java as a language may be very nice, but it’s certainly not too fascinating for beginners. If your learning programming on your own, like I am, I would recommend starting this book after you’ve come to grips with the object oriented matter in the Python book. That issue aside, it is a very good book and I personally like its style slightly more than I do the Python one’s. One major scoring point is that there are a number of exercises at the end of each chapter which involve both writing and reading/fixing code. This book will also come in handy if you’re studying for the American AP exam, but I’m not quite sure if it covers all the bases. I would suggest combining this with the BlueJ IDE, which’ll let you sidestep many of the practical hurdles involved in using Java as a beginning language.

How to Design Programs

This book is designed from the ground up to make you learn programming that is data-centric, i.e. the program’s very purpose for existence is the data that it manipulates. Unlike other programming books that focus on specific concepts as a path around which to structure your learning, this book focuses on data: you start by using smaller, atomic types of data and then move on to using mroe complex data structures. This book uses the functional programming language Scheme. But this books comes with its own dedicated environment: DrScheme. DrScheme helps beginners tremendously by hiding obscure syntax features until the time is right. It does this by providing not just standard Scheme, but a number of subsets containing only the features that you will need. As you progress through the book you move on to richer and richer subsets until finally you’re ready to use full-fledged Scheme. The book focusses on the ‘why’ of a program rather than the ‘how’.

Structure and Implementation of Computer Programs

Think of this as the last one’s big brother. SICP has been the textbook for MIT’s introductory Computer Science for the better part of two decades. As you can well imagine, this not for the faint of heart. However, once you set your mind to it, you’ll find that the book deserves its reputation as a computer science classic. It’s written in a simple no-nonsense style and like HtDP, it teaches you programming, not a programming language. It uses Scheme, but it makes and effort not to let your attention be drawn to what language you’re using. The book drives home the fact the computer is just a tool and your head is where you have to do the real work. That being said, there is probably no point in reading this book unless you intend to make computers your career. Also, having some amount of programming experience would help you on your way. This book is also rather intensely mathematical, and so make sureyour math skills are well polished before you embark on this journey.

Programming from the Ground Up

This book takes a different approach to programming: it’s basic premise that you can only really learn how to make a program if you understand how the computer ticks inside and what it does when it runs your program. As a result of that philosophy you are required to get up close and personal with the computer and that means assembly language. Yes the book uses assembly language (x86 assembly to be specific), but all the examples are very thoroughly explained and if you have patience in abundance, you shouldn’t have any problems. What sets it apart from SICP, is that while SICP approaches programming from a mostly theoretical aspect, this approach is decidedly practical. Again, probably not worth your time unless you plan on computer science as a career.

Personally, I think all the above are very good books. Of course there is the inevitable question of choice. I’m currently working my way through the How to Think Like A Computer Scientist books (yes, both of them). Once school is over I will try push through How to Design Programs and finally go through SICP and Programming from the Ground Up. All in all, I think all of that should keep me busy for the better part of a year. So in a year’s time, come back and check on my progress. If you’d like an IDE to go with your new book, check out the next post.

I’ve started teaching myself Java, right from the basics and as a guide I’m using the Java version of the How to Think Like a Computer Scientist book. One of the exercises at the end of the fifth chaper (called Fruitful Functions) is to implement the Ackermann Function as a recursive method. The Ackermann function is mathematically defined as:

Now, the Ackermann function is quite well suited to computerization, it takes little real intelligence to solve for any two numbers, and is mostly repetitive calculation (which computers are good at). It took me less than a minute to implement the function as a Java method as follows:

public static int ackerman(int ack1, int ack2){

if (ack1 == 0)

	return ack2+1;

else if (ack1 >0 && ack2 == 0)

	return ackerman(ack1-1, 1);

else if (ack1 >0 && ack2>0)

	return  ackerman(ack1-1, ackerman(ack1, ack2-1);

)

I passed it to the compiler and the compiler replied with a cheery: “missing return statement”. Since I already had three return statements, that meant that there was a possible path through the method where the method would end without a value being returned. The Ackermann function doesn’t work with negative numbers, so I had already implemented a check for negatives before the function call. I tried putting in another check for negatives in the function itself, but that didn’t work. By this point I was getting rather frustrated because the above code would catch all non-negative numbers and produce appropriate returns. I ran the code in my mind with a few small numbers and everything seemed to check out as it should, the values of ack1 and ack2 would keep on reducing until ack1 hit zero and the method would end with a proper return.

Finally on a hunch, I decided to remove the last if-else and make the last return statement free-standing. Semantically it was the same thing, because there was only one possible case if the first two conditions were not satisfied. And for some reason the compiler thought that this new version was perfectly passable. I haven’t entirely ruled out the possibility that there was really some path that would have resulted in no return. But I think that it is far more probable that the compiler for some reason couldn’t handle the multiple recursions and simply gave up. Of course, I’m not an expert in these things and if someone knows of a proper explanation please let me know. Until then I’ll stick to the knowledge that a computer is still quite some distance away from what would be common sense to a human (or at least the Java compiler is).

Learning a new language (human or computer) isn’t always easy. But it helps if you have a good teacher, who makes things fun as well as interesting to learn. Sometimes a good book can make things a lot easier. I’ve been wanting to learn Python for a good few months now and being the dedicated netizen that I am I turned to the Internet for tutorials and howtos. Though Python documenatation is fairly complete and quite usable if you are trying to teach yourself, it can be rather bland at times. Luckily for me, Beginning Python: From Novice to Professional from Apress came to my rescue.

Beginning Python is written by Magnus Lie Hetland, author of another Apress book, Practical Python and a number of well-written online tutorials which are available at his website. Beginning Python isn’t meant to teach you everything that there is to know about Python or programming. What it tries to do (and succeeds at) is to give you a good head-start from the basics upwards. The book covers a fair amount of matter, starting from the basics of writing simple, small programs to full-fledged GUI applications. Most importantly however, it does so in a pleasing, conversational style. Each chapter is fairly self-contained, dealing with a particular aspect of Python programming, which means that you can learn at your own pace and even skip a few chapters without too much difficulty. But what makes the book stand out from the crowd is that it not only gives a working knowledge of Python, it helps you figure out what to do with that knowledge. The book includes 10 programming projects including things like an XML converter, and internet messaging system, a file transfer program with a graphical frontend and even an interesting little game. Most chapters also come with a set of suggestions at the end about how you can apply what you’ve learned: a great way to keep yourself busy if you’re bored

While the book is called Beginning Python, there is some amount of more advanced information like network programming (including working with CGI and SQL), using GUI toolkits and other practical things like testing, debugging, optimizing and packaging programs. At the same time, it should be noted that the book does not intend to turn you into a complete master: the advanced material is enough to get you up and running, but do not cover the topics in great depth. All things considered, the book will probably be useful to you even after you have a fair mastery of the basics. It’s clean structure and good formatting allows it to be used as a quick reference as well as a textbook.

The book is definitely worth a buy if you’re interested in learning Python but have been keeping it off for want of a good resource. The $45 price tag is a bit steep, but it’s worth it for a book that will take you a long way and will probably still be useful even after a good few months.

I’ve come across numerous Linux books since I started using Linux about a year ago. From what I’ve seen Linux books generally fall into two categories: Firstly, books that are about specific distros (Mandrake, Red Hat, SUSE etc.) and books that are about general Linux topics (like BASH scripting, networking, security). For people who are beginning Linux, it’s the first category that is most useful. Most such books are about the popular distros. In the past they have included the likes of Red Hat and SUSE. Recently Ubuntu Linux has joined the ranks of the popular and mass user distros, and Beginning Ubuntu Linux is one of the first books written specifically to give a helping hand to people who are beginning their Linux journey with Ubuntu. And that includes people like me.

This book is different in many ways from other similar books that I’ve come across in the last year; in fact in seems to be as different from other books as Ubuntu is from other major distros. The back of the book says that the book is “Written for newcomers to Linux, yet comprehensive enough to appeal to even seasoned users”. And they are quite right about it. The book does not just cover how to get Ubuntu installed and running, it also takes a good look at the common applications that any computer uses: office and mulitmedia programs, internet software and even some slightly more advanced topics like making backups, networking with other computers, making sense of the Linux filesystem and optimizing your system for better performance.

Most Linux users, especially new users today are exiles from the world of Windows and for them adjusting to the Linux world can sometimes be a challenge. This book accepts the fact that most of it’s readers will be coming from Windows and will need a helping hand figuring things out. The two most important questions asked by any Windows exile are: “Can I use my favourite Windows programs in Linux?” and “Do I have to type in a lot of weird commands?”. This book anticipates these questions and makes a determined and sincere effort to gently introduce the Linux newbie to Linux equivalents of comon Windows programs and also to the weird and wonderful thing that is the command line. I especially liked the chapters devoted to the intricacies of the BASH shell, and even though I’ve spent a good deal of time at the Command Line, I still learnt a new trick or two.

But of course do actually get the most out of the book, you have to have Ubuntu installed on your computer. There is an in depth guide to installing Ubuntu, which holds your hand through the whole process and even helps you through the often confusing process of partitioning and also tells you what to do if you run into one of the common errors. it then goes on to take you on a tour of Ubuntu’s GNOME desktop and helps you set up your hardware and get connected to your home network and the Internet. There are also sections to guide you through conecting scanners and cameras and using USB storage devices and installing graphics card drivers. There is also a section on installing a firewall and securing your computer (which includes an introduction to the user system in Linux).

The book is replete with screenshots, which make sure that the user encounters no confusion while installing and configuring her or his system and the layout is clear and simple. But what impressed most about the book is not how well it guides the new user, but that the book begins with an extensive account of the history of Linux and the free softare movement. And it is one of the few books that I have encountered that give due credit to both Richard M. Stallman and Linuz Torvalds acknowledges the part played by the FSF and GNU software. The book ensures that only will a reader become an adept Linux user, she or he will know about the people and the ideas behind Linux and understand appreciate the differences between Free and proprietary software.

In the end it all boils down to this: is it really worth paying $39.99 for this book? The answer is yes. If you’re a new Linux user, this book will certainly save you a lot of time scouring forums and documentation for solutions to simple problems and answers to common questions. Even if you’re reached the stage when you can manage linux without too much of a fuss (like me) you can still hope to learn a good few things from this book. And thanks to the spirit of humanity and free software, you also save bandwidth charges because this book comes with a complete, no-strings-attached copy of Ubuntu on CD. If you’ve been hearing about Linux, but have been waiting for someone to hold your hand when you take the plunge, just get this book and get wet!