Posted
by
samzenpus
on Wednesday January 11, 2012 @06:16PM
from the read-all-about-it dept.

Michael J. Ross writes "The last few years have seen the emergence of several significant advances in web technologies, including HTML5 and CSS3 — all impacting the development of traditional and mobile-centric web sites. In turn, various technical book publishers have released titles addressing one or more of these technologies. While one book may focus on HTML5 and the new JavaScript APIs, another might include extensive coverage of CSS3, with little mention of JavaScript. A recent title, Sams Teach Yourself HTML5 Mobile Application Development in 24 Hours, focuses on some of the more commonly employed elements introduced with HTML5, and how they can be used for creating mobile sites and applications." Read below for the rest of Michael's review.

Sams Teach Yourself HTML5 Mobile Application Development in 24 Hours

author

Jennifer Kyrnin

pages

496 pages

publisher

Sams Publishing

rating

8/10

reviewer

Michael J. Ross

ISBN

978-0672334405

summary

A tutorial on building web sites and apps with HTML5.

This book was authored by Jennifer Kyrnin, who has plenty of experience in using as well as teaching web design techniques, and who curates the Web Design / HTML section of About.com. The book was put out by Sams Publishing (an imprint of Pearson Education) on 25 November 2011, under the ISBN 978-0672334405. On the publisher's page, visitors will find the book's description and table of contents, and some sample content in a PDF document, including the first chapter, "Improving Mobile Web Application Development with HTML5." The page appears to not list any reported errata. This book is available in both print and electronic formats (EPUB and PDF), but prospective buyers should be warned that the e-book is less than seven dollars cheaper than the print version ($25.59 versus $31.99), despite the huge disparity in production and distribution costs. The author's web site offers additional information, primarily in the form of a newsletter devoted to HTML5. The preface claims that this second web site has the example source code from the book, as well as ways to ask questions and report errata; but if so, they are well hidden, as of this writing.

Spanning 496 pages in total, the book's material is organized into two dozen chapters, as is usual with any of the books in the "Sams Teach Yourself X in 24 Hours" series. Readers may well wonder if this artificial constraint causes the various authors to structure their books in a way that does not always make sense. In the case of this title, there does appear to be some forced splitting of material between two chapters, namely, "Building a Mobile Web Application" and "Converting Web Apps to Mobile." Conversely, three topics that may deserve their own chapters are lumped together, in "WebSockets, Web Workers, and Files." Moreover, it is arguably unrealistic to expect that the typical reader will be able — or would even attempt — to read and comprehend a technical book of such length and subject matter in only 24 hours — to say nothing of the time required to type in the sample code (in order to test it and reinforce the information learned). This "teach yourself in 24 hours" format borders on "brain surgery in three easy steps." Lastly, it leads to silly phrasing such as: "a result of reading the hour" (page xvii).

The chapters and appendices are grouped into four parts, the first of which is titled "Building Web Pages and Applications with the Open Web Standard." The structure of the first chapter is replicated in all of the other chapters: The author briefly lists what the reader will learn, and then begins explicating the concepts, illustrated with example code wherever appropriate. Each chapter concludes with a summary (which is of no value), several FAQs (whose material should instead be folded into the main chapter content), and a workshop section comprising quiz questions and exercises for the reader to tackle. Part I's eight chapters introduce HTML5, web applications, the W3C Open Web Standard, the new HTML5 elements and their attributes, CSS3 (with justifiably limited coverage), mobile browser detection, JavaScript, and jQuery. Then the author presents the basics of how to build mobile web apps, both from scratch and from using a non-mobile web site as a starting point.

Part II, "Learning the HTML5 Essentials," goes into greater detail of numerous basic aspects of HTML5: the new HTML5 sectioning, heading, and semantic elements; the semantic repurposing of some HTML 4 elements; the new canvas element (with limited coverage of this extensive topic); new typography support; audio and video elements; new form capabilities; HTML editable content, spell checking, and other user interactivity; microformats, microdata, and RDFa; in-page drag and drop; and new functionality for linking (the <a>, <area>, and <link> elements). Readers should note that the discussion in the ninth chapter on the new sectioning elements starts off rather confusingly, but soon improves, making it well worth reading.

The third part of the book, "HTML5 for Mobile and Web Applications," begins with an introduction to web apps, as well as the HTML5 application programming interfaces (APIs) and data sets upon which they may rely. The author then discusses specific APIs that can be of great use in web apps — specifically, the WebSockets, Web Workers, and File APIs, which allow one to make asynchronous connections between the app and a remote host, perform scripted background processing, and access local files. The remaining chapters show how to: make a web app usable even when it is disconnected from the Internet; save data on the client side (using local storage, session storage, Web SQL, and IndexedDB); control the browser history; geolocate the client; and convert an HTML5 application into a native mobile app, with detailed information on using PhoneGap. Aside from the index, the book concludes with three appendices that cover: answers to the end-of-chapter quizzes; a list of the HTML5 elements and their more commonly-employed attributes; and a list of other books and web sites that address HTML5 and mobile design and development.

The average programming book — particularly one of this size, and in a first edition — will contain some errata, and this one is no exception: "shortcut style" should read "shorthand style" (page 37); "Specific[,] Measurable" (87); "complimentary" should read "complementary" (93); the "By the Way" section on page 131 is missing a close parenthesis; "html5elmeents" (136); "will [be] eventually" (184); "a straight line [] they" (184); "makes build[ing] forms" (223); "method[s] exist" (362); "the page [it] is on" (383); and "()creates" (390).

There are some other parts of the text where either the author or the editorial team may have been careless — for instance, the figcaption and figure tags repeated on pages 16 and 18. Fortunately, such cases are few and far between. The HTML, CSS, and JavaScript code is generally of decent quality, except much of the HTML markup is not indented properly. In the JavaScript code, most if not all of the string concatenation is jammed together, making the elements difficult to distinguish (e.g., page 72). Also, some of the HTML does not utilize the more streamlined attributes of HTML5, such as <script type="text/javascript"> (e.g., page 20), or is not well formed, such as </li> tags missing (e.g., pages 236 and 250).

The author occasionally uses terminology that would be comprehensible only to someone who already has the knowledge that the narrative presents for the first time, without providing at least a quick explanation, e.g.: the !"!" JavaScript operator (page 55); the terms "rollover" and "user agent" (page 69 for both); and "the manifest comes up 404 or 410" (page 342). Some of the advice may be true, but is rather outdated, such as the admonitions in the first chapter to not use frames, nor to use tables or spacer images for layout. Those principles were validated and disseminated many years ago. Some statements could easily be misinterpreted by beginners, e.g., "As long as your HTML file is in the same folder as your style sheet file, it will load your styles when your page is loaded" (page 36). Other statements are not explained in detail or substantiated, and consequently the reader will probably not understand the reasoning behind it, e.g., "using the min- and max- extensions is more effective" (page 61), and "a separate mobile domain [] makes your mobile site easier to find" (page 10). Readers may disagree completely with some of the claims, e.g., "XHTML [is] very difficult to write" (page 2).

There are only two discernible problems with the production of the book: In some of the HTML code, curly quotes are used (e.g., page 303). Secondly and more importantly, the san-serif font used to indicate keywords looks much too similar to the serif font of the regular text, causing the keywords to blend into the surrounding material.

Yet the main problem with the narrative is the somewhat erratic manner in which the author skips from one topic to the next, often providing just a few paragraphs or even sentences for each topic — giving the impression that critical information may have been neglected as a result of the less-than-methodical organization of the material. Most of those topics are discussed again, in varying levels of detail, in later chapters. This is not optimal, because technical readers generally hope to find full coverage of any given topic in one place; hence, it can be frustrating if the information is scattered throughout a book. This is especially true if the reader has already read the book in full, and is now returning to it in order to utilize it as a reference source. For instance, in many cases, attributes are presented, but without detailed explanation or examples. Fortunately, the worst of it seems to be confined to Part I of the book, which contains most of the introductory material. Most if not all of the key concepts appear to be addressed to at least some extent. Lastly, some of the information that should have been presented right up front, is not, e.g., the definitions of HTML5 on pages xiv, 1, and 52.

Unlike most programming books nowadays, this one has few instances of phrasing that would baffle the reader for long, and there are no goofy attempts at humor. For most of the topics, the information provided is the minimum to achieve the bulk of the desired results. The advantage to this is that the narrative is generally concise and quick to read, and the author is able to cover a lot of ground without having to package such a broad topic in a (more expensive) tome. Some of the narrative is quite good, such as the explanations of the various browser exceptions involved in the HTML5 drag-and-drop functionality.

Despite the aforementioned blemishes, this book is definitely worth a look, because it is currently one of the most complete tutorials for learning how to use HTML5 for creating mobile apps and web sites.

yeah but that was then, and this is now. the web has moved on since then.

that's the reason why html5 is failing to gain much traction - no matter how good the reasons for turning the clock back to those glory days of "this website is best viewed with[insert favorite browser here]" the consumers are just not interested. and the devs are not that keen either.

have a look at how the html5 mobile gaming company Moblyng are doing... hint - they've shut down in the last week after spending 10 million dollars of ot

Who has 24 consecutive hours, or the stamina to spend them on one topic?

I own several of the 24 hour books, and I can safely say that they're not going to make you an expert in 24 hours - but you'll definitely have enough knowledge to get yourself into trouble:)

The best I've been able to do is in 4 hour chunks, followed by a 1-2 hour break. Any more than that and my eyes start to cross. Each hour/chapter can (generally) be done in an hour - although most should be given more than an hour of attention for the sake of deeper understanding.

I don't own this particular book, so I can't attest to the 24-hour-ness of it's content.

The only book of this series I ever had was "Teach yourself DirectX 7 in 24 Hours" and they quite explicitly stated in the book (I think on the cover even) that it's not intended to teach you the subject matter in 24 consecutive hours from start to finish, but in 24 lessons of approximately one hour.

I only got partway through that particular book, but I learned enough from the few chapters I read completely, with selective reading of others, to go from zero knowledge about DirectX programming to writing a 3

Yes, as long as you're expecting an incredibly shallow and incredibly narrow knowledge of the subject. In 24 hours you could probably learn enough German to go to a bakery and order some hard rolls, but you wouldn't be able to learn enough to conduct business beyond what you'd been taught to say and you certainly wouldn't have a deep knowledge of any of it.

I think if you break it up into 2 hour segments you can sorta learn it OVER 24 hours. But that doesn't include "lab" time. Go off and apply the knowledge through trial and error until you full understand it, and then come back for another 2 hours.

24 hours == 8 weeks of a 3x per week course. That's a reasonable amount of time to learn something.

I'll blow my moderation on this post to say: I wrote the "Perl in 24 Hours" books and this is exactly how it started out. I'm not sure how the other 24 Hours authors did things, but this is how I did it. I taught perl in night classes in the late 90's as part of a retraining effort for programmers that used COBOL or something else.

Classes were two nights per week with about 3 hours of effective class time, o

That being said, there's still value in these types of books for some.

I first started taking software seriously (having dabbled throughout childhood) when I bought a copy of http://www.amazon.com/Learn-Three-Days-Popular-Applications/dp/155622298X [amazon.com] and Turbo C++ (in 1991?) before a really long deployment to the Pacific. Now, it took me more than three days to really *get* pointers, LOL, but that little digest of a book was a wonderful start for me. 20 years later, I am a very senior software engineer and a

The art comes in putting in the right search terms (where previous language knowledge makes this possible) and eventually you just kind of pick it up and w time you get better and better as you solve various scenarios and cases in the new programming language.

Still, at least at work, I like to have a book handy just in case I need to grasp a concept or somet

Yeah, if IIRC I read somewhere that most people cannot take in more than 50 or 60 minutes worth of new information at one sitting without a 5 or 10 minute break or preferably longer on any given subject. If you do, the stuff that comes after progressively 'sticks less'. You get some of it but not as much as if you had a break. And not as much if you took a break to the next day. Works for me. Plus in order to really learn it, you need to take that one hour's reading and apply it by writing some of the code