This is the second edition of Randall Hyde’s 1996 book on high-level assembler. It provides an introduction to writing assembler programs using the High Level Assembler (HLA) that incorporates many features found in higher-level languages.

The book originally started off in 1989 as a book for students of a course on assembler language the author was teaching and evolved into the first edition in 2003. This updated version was released in 2010. While assembler language is mostly used in the lower reaches of computer platforms in areas such as device drivers, it remains a fact that everything else in modern operating systems is built on top of it. While modern high-level languages have abstracted away much of the need to know how a program is executed, if for curiosity only (and what programmer is not?), its probably good to know what is going on in the lower-reaches of their computers.

In the book readers will learn how computers are programmed at the assembler level, using the HLA and how to write software with it in assembler.

The book follows logical course, starting with first principals about memory storage, variables to procedure calls, arithmetic, before getting into the more advanced features the HLA provides for. The book itself is filled with code examples. For those of us who might have last programmed in assembler in 1989, most of it will feel familiar.

Using the High-Level Assembler begins at the start of the book and is built-on as the reader progresses. Compared to high-level languages, assembler is actually very simple and hasn’t changed a lot in decades, you are still copying data or manipulating data and storing into memory addresses, but that’s also the problem with it: with assembler that how everything is done, hence it’s a lot of work translating a lot of the higher-level ideas down into assembler. What Randall Hyde’s HLA brings to assembler is a C-like syntax that is mixed in with the regular assembler syntax in a way that goes beyond macro assembler, so that readers more familiar with high-level languages will feel more comfortable – and less typing is better for all.

In short, there aren’t any other current books on programming in assembler that I’m aware of, but this book is readable, so if this is it, then this pretty good. It will teach programmers right from first principals and by the end of the book, readers will be pretty comfortable writing in assembler.

First published in 2002, Free as in Freedom is the story of free software activist Richard Stallman. Stallman is best know for created the Free Software movement that led to the General Public License (GPL) which today under-pins today’s open-source movement. While his rigid stance on issues and use of wording related to free software have certainly earned him his share of detractors both inside and outside the community, without him, the modern software industry might be a lot different.

The book goes back and forth between his present work and Stallman’s life growing up in New York, later working at MIT’s Artificial Intelligence (AI) lab and to the creation of the Free Software movement. It was at MIT’s AI lab where a set of incidents convinced him that the sharing culture that existed among computer scientists in the 1970s needed to be protected form commercial interests that wanted to monopolize knowledge for commercial advantage. While his “Rosa Parks moment” might have been not being able to get the source for the software that controlled a printer in the computer lab to fix a problem with it- as was common practise then – it essentially crystallized what was going on in the late 1970s as computers where moving out of computer labs and large businesses and into the mainstream: software was becoming valuable.

In a lot of ways, Stallman grew up in the same world as Gates, Wozniak and other computer pioneers in the 1960s and 70s: the pre-personal computer world where the only accessible computers where large machines found in some school labs and research centres. While Stallman’s appearance today is somewhere between an Old Testament prophet and Carl Marx – which usually depends on one’s views on open source – while he was political, Stallman was never a “hippy”, partly because of the anti-technology / anti-intellectualism that was popular in some circles back then didn’t appeal to him; but where many of his peers — and arguably with a lot of hackers then and now — avoided getting involved in politics, Stallman did just that by starting the Free Software Foundation in 1985 and later created the General Public License (GPL), arguably one of the best-known (non-religious) contracts . The first version of the GPL appeared in 1988, it didn’t get too much attention until authors, including Linux creator Linus Torvalds, started using it. At that point, the implications of it sunk in: previous to it, software was in general owned by somebody or existed in the “public domain” which basically meant it was available to anybody to pick up and own, therefore removing it from the public; the GPL effectively created a way to keep something in the public domain, and, more troubling to some (including famously Bill Gates), it said that if something licensed under GPL was incorporated into another thing, that thing would also take on the same license. For companies that had spent 20-odd years believing that secrecy and exclusivity gave them an advantage, Stallman’s GPL was a truly dangerous idea.

Even by 2002, when this book was first published, a lot of his ideas had moved from the fringe to accepted. There are now several dozen licenses that, while generally more restrictive, take inspiration from it, though usually taking a few steps back from it’s clear-cut goals to satisfy some interests. He did lose the battle over “Open Source” and his preferred term “Free Software” (at least in the Anglo-sphere) but Stallman is still very much active particularly in developing countries, where many of the idea of open source are finding even greater acceptance.

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.

The Problem:
For most of the history of the web, just getting something up on the screen that resembles your original design — in two or more web browsers — has been a challenge on it’s own. Today, browsers have become more standardized, and libraries like jQuery UI and the Dojo Toolkit are bringing desk-top-style interface widgets to websites. However while designers have the ability to create sophisticated interfaces, designing sites that are easy to use is still a challenge because the challenge is only partly technical.

Public websites (as opposed to those for internal use by an organization) often have to be both a tool for performing a task and an advertisement for the website’s brand, combine this with the need to be quickly picked up by new visitors and easy to use by those familiar with it gives the designer an interesting challenge balancing these different goals. While not touched on in the book, Apple’s iPhone/iTouch offers a counter example: websites designed to run well on these devices try and mimic the native UI so that users familiar with, say, selecting podcasts feel at home navigating websites.

What Does the book teach?
As their bio indicates, Bill Scott and Theresa Neil have both been involved in website design for several years and many of the examples are drawn from websites they’ve worked on and they draw on this experience in this book. Designing Web Interfaces takes the reader though a series of principals for creating websites that are easy for users to use. Each principal: Make it Direct, Stay on the Page, Provide an Invitation and React Immediately is given its section. In each section are a series of chapters each covering a set of design patterns that relate to that chapter and section. for instance, the Stay on the Page section has a chapter on Overlays that covers how to use dialogue boxes (such as those available in jQuery UI) effectively. The book pays a lot of attention to details, like how to visually indicate a page element can be interacted with using such as the example of a photo that when hovered over gains an icon and the background changes so the photo appears to become a button. At the same time the book has examples of “anti-patterns” – examples of what designers have done wrong according to the authors. One example given is over-using drag-and-drop to score movies when a simple star-rating might have been more effective. Other show how websites have evolved, for example Digg.com (or just ‘Dig.com’) originally made “digging” a story a 2-step process. Each chapter and section finish up with a wrap-up that includes a set of best practices.

What it doesn’t
The book isn’t so much about the overall design of the site itself, rather it goes the opposite way: right into the details of how an element should work. As well, there is little mention of the process of building the website once it has been designed- readers looking for advice on what JavaScript library to use will be disappointed, but there is enough material covered in this 300 page book already and it’s probably for the better, the examples here will be relevant for longer than some of the libraries or frameworks popular today will be in a few years.

Conclusion
Designers have gone from click-able text links to having nearly the full palette of of UI options available to desktop applications. With that amount of choice, mistakes are bound to happen. Designing Web Interfaces doesn’t try and teach everything about web design, there is almost no coverage of the implementation details, but what it does cover is a lot of common situations that might come up when creating a website and this book offers a guide to how other designers have approached the problems – and sometimes how they have got it wrong. They layout of the book is very easy to follow: plenty of illustrations and a clear examples along with various break-out boxes. This is a good reference book to keep around; the principals are good ones to keep in mind, even if your project doesn’t quite fit into the cases provided, though I think anything larger than a personal website is going to get into areas where the lessons here are applicable.

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.

However once your past that, Taking your iPhone to the Max has a lot of coverage of other software that can be installed and useful websites. Where the book really shines is the knowledge of 3rd party websites and applications that Sadun brings to her book. These applications range from GSM codes to where to go for information on un-locking your iPhone — needless to say, a lot of the material covered isn’t Apple-approved — but this is your iPhone you’re taking to the max.

Finally, the book has a clean layout with a number of tips spread out over nearly every other page. The layout is black and white, but its quite attractive, with plenty of screen-shoots. The tips are broken out from the text and make it easy to skim the topic. The clean layout makes it easy to find material in this book.

For a small book, there is a lot of material covered in here. On one hand, it covers pretty much everything that the manual does, but then it adds the author’s own knowledge of useful 3rd party applications and websites that let you take your “iPhone to the max” — this is really the part that makes this book worth purchasing — and finally, it has a clean layout that makes finding things in the book straightforward.

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.