If you have done a review of Hello Android and would like it mentioned, please put a link in the comments below.

Alex Mak’s Blog

Hello Android is a very well written book by the developers of Android. The writing style is great, the author speaks to the developer and gives a hands on approach to guide the reader to build applications from scratch. Link

Caffination.com

I was recently sent a copy of Hello, Android, by Ed Burnette from The Pragmatic Bookshelf. I was greeted with a friendly, educational and entertaining resource. Link

DrDobbs.com

Hello, Android is a book best served to developers already comfortable with Java and have at least some experience with developing mobile applications…the author’s quick teaching pace and desire to stay current with the Android platform make Hello, Android a useful, timely book that continues to be one of the premiere books for learning how to leverage the Android development platform. Link

LearnComputer!

Hello, Android: Introducing Google’s Mobile Development Platform (Pragmatic Programmers) by Ed Burnette is a fantastic book for beginning Android development; it is a practical, no-nonsense guide that can be powered through in a few days to have a great base for Android development. Link

YYZtech.ca

One of the first questions the book tries to answer is, “What is the need for yet another platform for mobile devices, including some already built around Linux and Java?” The answer they give is that Android isn’t just an OS but an open source environment …[and] other features that make developing applications easy. Link

Price: —
( customer reviews)

0 used & new available from —

The reasons I liked this book are mainly that it’s focused on HTML, doesn’t try and teach PHP or another server language, yet still covers things people need to know like how to organize a website, choose an ISP and FTP a site up. The second think I like is that, unlike a lot of the earlier books, it has a strong focus on CSS. Finally, the book has an attractive layout with good use of colour and plenty of screen-shots.

In the past, I found that many books on web design would cover HTML, but usually didn’t provide much of an introduction the CSS other than those Dynamic-HTML (DHTML) – focused books that sort-of became a fad in the late 1990s. Partly I think the reason that these earlier books shied away from CSS was the often wildly-different ways browsers interpreted nearly any kind of CSS beyond the basic font-controls. While it is still true that there are numerous rendering differences, most current browsers give a fairly consistent rendering of CSS up to version 2.1 – CSS 3 is another story and, wisely, this book doesn’t go there.

Where the book falls a bit short is in getting around browser differences, while some books have devoted whole sections to that, I think there could have been some more coverage of that, or maybe it was avoided as it would have probably been confusing to people just learning the HTML. It might have been nice to see some more coverage of JavaScript, but again, JavaScript really would have needed it’s own section (or book) at least.

What puts this book ahead of a lot of others is the coverage of things you need to know in order to write websites beyond strictly HTML/CSS. A couple of these are: once you’ve got more than 4-5 pages, it’s important to organize a site so it’s easy to find and change things when you’re updating. Everybody doing web-design these days should know basic SEO, and that’s covered in the chapter. Related to maintaining and SEO is creating properly formatted pages, and that’s covered as well. Finding a web hosting company and learning FTP is covered too. I also noticed that in the section on graphics, the authors give a bit of a tutorial on using the free Gimp image editor – with a new copy of PhotoShop now costing nearly $1000, it’s good the authors are showing readers, who might not have $1000 to spare, some other options.

It’s good to see a book that doesn’t over-reach. Sams Teach Yourself HTML and CSS sticks mostly to that. Readers might want to pick up a book on CSS afterwards as it really is coming into its own with newer versions of the specification.

Speaking of CSS, on the book’s cover there is mention of HTML5, but most of the coverage is limited to a page or two. Both HTML5 and a newer version of CSS (CSS level 3) are being worked on but not actual finalized standards, though different browsers support parts of the proposals. As of spring 2010, both are still a draft format and while the newest versions of FireFox, Chrome, Safari and Opera support many of the features, especially CSS3, Internet Explorer still supports none and even the much-discussed built-in video tag is of limited usage today because of different video format support with Safari supporting one format, Firefox another and Chrome coming up the middle supporting both formats.

So except for maybe not going into depth on how different browsers handle some parts of CSS, overall, if you are looking for a book for someone who wants to get started learning web design, this is good choice.

The first chapter starts with a bit on how “a network will improve your life”, which covers how a network can make your computers more efficient by connecting them together to share resources. I liked the plausible introduction about the user who never though they’d need a network, then somehow they find themselves having to run one as more computers enter the household. The next three chapters gives a bit of background on both the theory of how networks are organized as well as the hardware that is used to build the actual physical parts of the network.

The next section, starting with chapter five takes the theory and helps you design a network, including wireless networks. There is chapter six that has a lot of practical tips on how to lay out the wiring for a network so that it’s both safe and organized- something I haven’t seen covered too much in books on computer networks that usually leave the physical details out. WiFi networks are covered here, also some common-sense security tips that, if done properly can cut out a lot of casual snoopers.

After showing how to set-up file servers in chapter nine, the rest of the book covers how to connect various devices to the network. Network Know-How covers networking on Windows (XP and Vista), MacOS X and Linux (KDE, Gnome). Security is covered in several parts of the book and is given its own chapter: 13 (coincidentally?), as well. Page 153 has an interesting list of passwords to avoid (including many I didn’t know people used- like Fox Mulder’s password from the X-Files TV series.

Author John Ross has previously written two books on wireless networks, and “It’s never done that before”, the kind of tech. book I’d buy based on the title alone- and yes, it is a book on Windows troubleshooting. It feels like there is a lot of experience behind this book too; sometimes you read a book and you get the feeling the author just learned what they’re writing about quite recently; you don’t get that feeling with this book. The layout of this book might be simple, and the writing can be a bit dense but there’s plenty of screen-shots and back and white photos showing what network parts look like to keep the book readable. I liked that they start right with the hardware and have a couple of tips about the physical task of setting up a network, something that is often left out of the discussion of network set-up.

In a nutshell AIR lets developers write cross-platform applications in ActionScript or JavaScript- though ActionScript is given most of the coverage in the book. If this sounds a bit like Java’s “write once, run (or test) anywhere,” the comparison is a valid one– in fact, with the new 3D animation support and UI toolkit, AIR could be used places Visual Basic or DarkBasic are currently used. On the other hand, unlike Java, AIR includes a lot of help for developers ranging from a built-in database (SQLite), secure local storage, and a packaging system that makes updating your application much less work. However many of the applications available today, like Twhirl, MyStylez or the late Pownce, simply enhance existing websites.

Each chapter covers one feature of AIR explaining a feature usually with a fair amount of sample code. Code in the book is mostly written in ActionScript, though JavaScript fans should check out Adobe’s online documentation for how to use the AIR APIs in JavaScript. The first section is on setting up the Flex BuilderIDE and debugging applications. Unit testing is covered later in the book (ch. 23, Continuous Integration). I was glad to see more attention paid to writing solid applications and using developer tools. A lot of books of this kind don’t cover simple things like using an IDE’s debugger- maybe that’s another bonus of Adobe including an IDE with AIR- writers know this is what most users are going to be using to write apps, unlike say, Java where there might be about at least 5 IDEs in use.

Afterwards the book takes the reader though the various APIs AIR offers developers including opening native windows (AIR runs on Windows, MacOS and Linux), working with local files, databases and networks. Each chapter starts with a set of feature high-lights before delving into the API; for instance, chapter 16 on the encrypted local store points out right away some useful information like kind of encryption used and the fact that un-installing a AIR application does not automatically remove data stored in the local store – something security-conscious programmers would certainly want to know.

Unlike a few books of this type, AIR Programming also spends a fair amount of time on good practises for developing non-trivial applications. Besides the chapter on using the debugger, design patterns and using Cairngorm, a MVC-based framework, that’s given two chapters coverage. Agile programming is covered in section six which includes creating a build process using Ant, unit testing with FlexUnit and automated builds using CruiseControl. In short the book covers a lot of the practical advice for setting up a proper development environment besides finding your way around an IDE.

In conclusion, the book does a good job of showing readers how to develop AIR applications, what features are available and demonstrates some good practices to follow. I would like to have seen more information for web developers looking to port their applications over, but from the looks of the JavaScript documentation on Adobe’s site, it’s not that much more complicated. The layout of the book is pretty plain but makes for easy reading and there are numerous screen-shots and some diagrams. There’s a lot of source code printed in the book — which you can download from the book’s website, or from a Subversion repository. Also, the book’s appendixes have a fair number of resources listed in them for developers looking for online resources. Essentially, if you know ActionScript already, this book would probably have you writing basic applications in a short time.

The book is written for the 5.x version of MySQL and so there’s coverage of 5.x features like stored procedures, triggers, views, the archive storage engine and a number of other features. There is some coverage of features in version 6, such as the new Falcon engine as well, though these are mostly in the form of notes. Users of older versions of MySQL will also find notes in the book on features that are not available in order versions, and sometimes possible work-arounds. Also, for users upgrading from 4.x to 5, there are a few notes on when features such as data-types have changed from one version to another. For instance, some of the data-types (decimal or bit for instance) are implemented differently in version 5, than in 4.x, which might lead to performance improvements, or possibly unexpected results that developers might want to test for if upgrading their MySQL installation.

The book is divided into three sections: using MySQL, using it in your own C, Perl and PHP programs, and setting up and administrating an installation. Each of these sections take-up several chapters.

The first five chapters cover working with MySQL: creating tables, running queries, the various data-types and stored programs. As well as how to optimize your database though picking appropriate data types for your application’s needs, using MySQL’s explain command to determine where indexes might help. Other interesting bits are include how two-digit dates are interpreted and some of the geometric data-types that are now built-in. A point on data-types: MySQL has a lot and some of them have several different names but are actually the same thing and some used to be the same thing, but are now actually different. Is it any wonder that one of the goals of the Drizzle MySQL fork is to reduce the number of data-types? More importantly, understanding the different types lets you pick a type optimal to your application; readers will no-doubt have seen books listing table definitions that use the normal int type to index a small list of items (such as a category list), which is ridiculous if you know int is designed to hold numbers in the billions and, more importantly, uses maybe four times the amount of storage space required. In short, by the end of this section readers are going to be pretty comfortable writing MySQL code as there’s probably more practical MySQL-specific information in this section than most books provide– Addison-Wesley could probably sell it as a book by itself.

The middle section covers programming with MySQL. Examples are given in C, Perl and PHP. PHP developers will notice that the PDO library (built into PHP from version 5.1 onward) is used. As well, unlike a fair number of books teaching PHP this one actually has a notes saying that the examples given are just examples- and that this is not the proper way to write a secure application. Having read the 3rd edition of MySQL, I was wondering if some newer languages, like Python, would be included in this section, but not this time. This section pretty much shows how to

The last section covers how to administer MySQL. This covers everything from creating back-ups, using log files to setting up replication. This pretty much covers a lot of the day-to-day work maintaining a MySQL installation.

This is a big book (the book’s website joking refers to the 4th edition as “Doorstop IV”) but even if you don’t read all of it, it’s certainly a great reference to have around. The Appendixes at the end of the book are particularly useful, like PHP, MySQL has a lot of built-in commands for things like string manipulation, mathematical operations. There is a data-type reference in appendix B along with notes (such as how the bit type has changed from previous versions). Really this is a good book, and besides, if you ever give up on MySQL, this book can prop up your bed.

The name Drupal is Dutch for ‘droplet’, hence the water droplet icon found on hundreds of websites. Behind that icon is a content management system that has evolved over the years from a basic content management system into what has been called a “Swiss-army knife of web software”. As that statement might lead you to think, Drupal does have a reputation for having a steep learning curve, but probably not that much more than other content management systems become when you step outside the defaults.

Like many such systems it employs some kind of system of blocks of content that are skinned with a theme. How easy it is to make a site your own is what sets one content system apart from another. To see what’s possible, take a look at the Drupal.org website and one for a Toronto hot-spot: TheDrakeHotel.ca. All of these are Drupal sites, so it gives you some idea what’s possible.

If you’re familiar with the Model-View-Controller (MVC) pattern used by many frameworks then you could think of the blocks as the view and the modules are the Model and Controller. That said, this book is not about programming with the Drupal API, it’s for the user who has picked this system because they want to avoid that.

Briefly, the chapters cover an introduction to Drupal, covering it’s history, the community and it’s features followed by a bit on planning a site. Getting set up is covered in the next chapter. The book takes the reader through setting up a development environment, based on the Apache2Triad package, through they mention that XAMPP could also be used– that’s the system I used when following this book. Afterwards comes installing Drupal and fixing some common installing problems. Then how to set up an administrator account and create your first page.

Chapter three covers the basics of the Drupal functionality: blocks and modules. You lean how to install new modules, configure some common ones including forum and comments and search; then you learn a bit about blocks, including how to create a simple one of your own. Like many content systems, Drupal’s layout is based around blocks of screen space that are filled by modules.

Chapter four is on site configuration. Here you lean how to set up logging, error reporting and some site maintenance functions– basically all the things you need to know to keep your website running. Related, chapter 5 the reader is given an overview of access control. This covers the built-in roles, configuring new ones and managing users and user settings. You also learn here about Drupal’s more advanced features, such as its spam prevention tools.

Chapters six and seven cover creating content. The first chapter covers the types of content, working with content and the content related modules including the blog, forum, comments and page modules. Chapter seven introduces the Content Creation Kit (CCK) and taxonomy. The CCK allows the user to create their own content types without programming while the taxonomy system allows for categorizing your content several ways. Chapter eight teaches you how to go about theming Drupal. Here the reader learns about planning a theme, customizing an existing theme via the CSS files to create a new theme.

Chapter nine covers some of the more advanced features of Drupal: localization, caching, throttling, jQuery.

Chapter 10 is all about managing your website. This covers doing backups, setting up cron jobs, updating your website as well as updating Drupal and its and modules. Finally, the appendix covers deploying your new site. This covers all the usual points about checking your host out, transferring files and the database, then testing it out.

With the exception of chapter seven, I didn’t find too much in Drupal that complicated to follow. The book is quite easy to read, but I hoped there might have been more coverage of theming– there’s a lot of websites out there that scream “Drupal!” from a kilo away and making your own layout is one way to make a website your own. At approximately 350 pages, coverage of some of the more advanced topics is brief, but you’ll get a good overview of what’s possible with this system. The layout is black and white, but has plenty of screen-shots and is cleanly laid-out, so it’s quite comfortable to read. There aren’t a lot of current books on Drupal on the market, so fortunately, for the reader looking to get started, this is a good one.

Packt Publishing has, since 2004, made a name for themselves specializing in books on open source projects and this is their latest book on Drupal. As well as sponsoring an award for open source CMS, Packt has (as far as I know) a unique way of “giving back”; for each copy of a book sold, they donate a portion of the sale back to the project, hopefully ensuring the continuing development of a popular project.

With the definitions out of the way, readers then get into the start-up tasks. First, there’s looking for projects (find opportunities), deciding is it’s a good opportunity (this is a bit of office politics – you want to know soon if the your project has the necessary support from management) and even if the task warrants a project – one of the key points is that a project is not on-going maintenance – it has a goal and a completion date.

Once you have decided to undertake a project, the next steps involve a proposal, identifying stakeholders, setting up an organizational chart and establishing communication protocols. This is the soft skill side of project management — a lot of the work is keeping the people the project is for interested and informed on where the project is heading. Much of the advice is practical — including dealing with the stakeholders who just aren’t that interested in your project and picking a good project board – the less the better. Finally, once this is established it’s time to make sure everyone is on the same page and agreed on the deliverables (the specific things the project will achieve).

By chapter three (“Getting the Job Done”) we’re into the actual material many readers (including myself) think of as project management: setting schedules, breaking deliverables into discrete tasks. For that, there’s a lot of practical advice here – especially around making estimates and communicating them to stakeholders and team-members so they are not mis-interpreted as wild guesses or hard dates. Particularly good was the advice on refining estimates from a general size (is it a small, large or extra-large task), then, as the date got closer, change it to a more accurate estimate. As well as measuring performance, some management tools like work-flow and Gantt charts and issue lists are introduced in this chapter.

The last two chapters look at managing your team and completing the project. The “Keeping it smooth” chapter gives a good overview of the people management skills you will need working with team members. Not a lot to say here, but having done some management in the past, it covers all the bases well and it’s probably applicable outside of project management as well.

Like many of the new SitePoint books this book explains a complex topic with a few illustrations and a clean layout. They’re using that humorous information schema (light-bulb, bicycle horn, hand grenade ) to good effect. One example of this is in Getting Started chapter: There is a section talking about what goes in a Project Initiation Document (PID), and there are break-out boxes on what it is not meant to take the place of.

For an example of the layout, the “Keeping it Smooth” chapter is a good example of how this book is organized; Topics are broken up by headings with points arranged as lists of short paragraphs, which makes it easy to skim. While it’s a small book, only about 200 pages and about 25×20 cm – it’s still good to be able to skim.

The glossary covers the particular usage of words in the project management domain.

Appendixes A-C list some tools,other resources (books and blogs) and C provides a list of qualifications and associations.

For a topic I was quite unfamiliar with when I started, I’d recommend this book as a good overview to the topic. The chapters follow a chronological order through a project, from picking a project (including those to avoid), planning and executing, managing the staff and stakeholders and finally, finishing your project and handing it off.

The author, Meri Williams, writes two blogs: GeekManager and Meriblog which readers might want to check out for further material. While each field has it’s jargon, project management has a number to learn – and this book does a good job explain it.

I expected a book on the core GoogleApps suite like gMail and the office applications (not to be confused with the recent Google App Engine programming environment), but App Hacks goes further into not only other Google properties like Bogger, YouTube and GoogleEarth. At the same time, they don’t avoid mentioning non-Google applications, such as Zoho office or some of the other on-line RSS feed readers in the Google Reader chapter.

It took me a bit of time to decide who this book is for -  it has some hacks aimed at web developers, others are useful for anyone, but that seems to be the way these books go. For readers, they’re marked with a PageRank-style bar indicating easy, moderate or advanced, so that gives you some guidance.

On the design, this book is different, more modern look from the older green/white books. As well as being moved under the Make brand, O’Reilly’s ‘Hacks series of books have undergone a design change in the last year or so, from the compact size to a bigger format – actually, some readers might notice that they seem to have taken the smaller layout and just added a wider right column that can be filled with additional information. The extra space is nice, but for the most part, it seems to be just extra blank space. I like the bigger format, and maybe future books with take more advantage of the extra space.

After a brief introduction to the apps, installing, the tool-bar and collaboration (one of those small things Google Apps do well) and other tasks common across all of them, the sections are:

• Meet the Google Docs family
• Google Documents
• Google Spreadsheets
• Google Presentations
• Become a Gmail power user
• Customize your Google homepage
• Manage events with Google Calendar
• News with Google Reader
• Manage photos and videos with Picasa and YouTube
• Create your own home page, blog or group
• Dive into Google Maps, Earth and SketchUp 3D
• Google Analytics and beyond

While there are plenty of hacks that are intended for web developers or programmers, ranging from straightforward cut-and-paste jobs like integrating various apps onto your blog, all the way to creating a CMS system using Google’s spreadsheet. A lot of the hacks show how to use various apps together, for instance, Hack 11 shows how to compose a blog post in Documents and then publish it to Blogger, WordPress or LiveJournal. The Gmail section, wisely, does not rehash the basics, but shows you lots of ways how to manage your mail (including some interesting ways Google’s engineers have made use of e-mail formatting). This section taught me a lot of stuff I had no idea about – being a regular gMail user, I’d almost recommend the book for those chapters alone.

There are no other books, that I’m aware of, devoted to Google’s office applications currently on the market, so if you are looking to get the most out of the applications this is about it- and it covers a lot of the beyond the basics nicely. As for the hacks, the author does point out several times who came up with the hack, so it there’s been commentary on it, you can go, um, “Google it.” Worth picking up for power users.

Coding is done in C using the included boot-able Linux CD that allows you to run Linux without having to install it. Included on the CD is the Linux OS, the code from the book and various tools- in short, you should be able to pop in the CD and follow along with the book.

Let’s be clear, that’s lots of C code, I haven’t seen this much C code in since the early 1990; But that’s seems to be necessary, this being a programming book that goes deep into how code really runs. You learn how to write a simple program, then disassemble it into assembly and debug it was the gdb (GNU Project Debugger), the goal here is to learn how things go on behind the code, how lines of C become lines of assembly and how those are stored in the basic building blocks of the computer – it’s here that things become possible that are not evident when looking at printfs and for-loops.

The lessons from the first chapter are applied in Exploitation as the reader learns how small flaws in the code can open up holes where an attacker can invade. Worth reading to are the antidotes about how various bugs create the holes in the first place. A good example is the IIS/Unicode exploit (p.117) where additional functionality added to the popular web-server has opened up holes in a previously secure system.

When I received this book. I turned to the chapter on networking first, and found it to be quite an in-depth low-level look at how systems network. Like the previous chapters, this two delves into a lot of how holes appear in systems, for someone curious about how this is done, there’s lots to digest, even if you’re not of a technical bent. Like the Exploitation chapter, this builds on Networking, showing how an attacker’s code is uploaded into a system. Related topics include hiding the attack though altering logs, avoiding crashing the system. Likewise, Countermeasures looks at how to detect and attack and ways to avoid it. Finally Cryptology coves some of the theory of how information can be encrypted and various attacks.

Even to the non-technical reader, there is a lot of discussion on the kinds of things that can go wrong with software, the overlooked bits that can be used in new ways (who would think a printer could be used to spoof an TCP/IP packets?, why would someone want to do this). If there ever was a time for the saying, “in the details” this is it, the details of what is possible is fascinating. Of particular interest might be the good description of the various network attacks, interesting how old vulnerabilities show up in new protocols (e.g. ‘ping of death’ makes a comeback in early Bluetooth implementations).

So, to sum up, this book is one of those that lives up to its title: yes, it shows you how to take advantage of sloppy or careless programming, but it’s also an ‘Art’, as far as learning how things fit together, as the author says at one point, a lot of the work is not being able to break somethings, it’s being able to take something apart, modify it and then put it back together.

It should be noted, there isn’t an over-arching animation project created in this book; However, readers could certainly follow along with their own project as the process is fairly linear, from the planning stages, through effectively using Flash’s library and a host of useful plug-in for tasks such as timing and motion tweening. There is a fair bit of coverage of Adobe’s After Effects, and the book discuses the pros and cons of doing various tasks in either software. With Adobe’s purchase of Macromedia in 2007, readers shouldn’t be surprised if the two products become more integrated with each future release.

For Flash animators, two chapters stand out in the 300 pages: There is one chapter on how to properly use Flash’s tweening tools so as to avoid the overly-precise look common with generated animations. A second is on 2D effects, covering common special effects like smoke, fire and water.

The book then wraps up with a chapter on how to avoid the “Flash-look”, which most readers will know exactly what this means- clean, mathematically-precise lines (would a computer produce any other?). Here the authors provide some straightforward ways to obscure the typical Flash look by altering lines to give them a more hard-drawn or at least, less rigid look. Combine this with the chapter on tweening and you’ll be on your way to some natural-looking animation.

This book is probably best for the reader who has some drawing experience, and preferably, a grasp of animation principals as well as some Flash experience. As with other Friends of Ed books, the layout is attractive, with lots of black and white illustrations and screen-shots taking the reader through each process.