The official Web site for the book is http://www.larryullman.com/books/modern-javascript-develop-and-design/. You can view the book’s Table of Contents there, too. And I’ve created a support forum for the book, naturally.

Over the next couple of weeks, some articles and videos I did in support of the book will be made available, and I’ll link those hear as that happens.

• About This Newsletter
• What Are You Thinking? => PHP 5 Advanced: Visual QuickPro Guide (3rd Edition)
• On the Web => President’s Day Discount at Peachpit.com
• On the Blog => Locale-aware Date and Time Formatting in PHP 5.3
• Q&A => What are some good general programming books?
• What is Larry Thinking => Your Knowledge Portfolio
• Larry Ullman’s Book News => “Modern JavaScript: Develop and Design” Coming Soon!

About This Newsletter

Through happenstance and a delay in finishing it, this newsletter actually has somewhat of a theme to it. Although that’s not a requirement for me, when I am able to theme a newsletter, it does make me happy for some reason. As the newsletter heading says, the theme is BOOKS! As you might imagine, it’s a subject that’s near and dear to my heart. But first, a caveat…

Although the goal is always to present information to you that I think you’ll benefit from or generally find interesting, this newsletter is a tad more commercial than I normally allow. In other words, if you buy some of the books mentioned in this newsletter, I might make a dollar or two (literally). Of course, there’s no pressure at all on you to buy any book discussed herein. I am sincerely trying to present those you may benefit from. And keep in mind you can also try getting any book that you might be interested in from your local library (for free!). With that caveat aside, let’s go to it.

As always, questions, comments, and all feedback are much appreciated. And thanks for your interest in what I have to say and do!

What Are You Thinking? => PHP 5 Advanced: Visual QuickPro Guide (3rd Edition)

Next month, I’m going to start working on the third edition of my “PHP 5 Advanced: Visual QuickPro Guide”. The PHP 5 Advanced book is somewhat different than my other books in that it discusses a number of individual topics, in a mostly non-linear order. The assumption the book makes is that the reader is already comfortable with PHP and MySQL, perhaps after having read my “PHP and MySQL for Dynamic Web Sites: Visual QuickPro Guide” book, and is looking to further her or his skills or learn about specific, tangential concepts. The second edition of the book discusses a lot of OOP (about 150 pages or so), plus: security, advanced database topics, networking, PHP and the server, PHP’s command-line interface, XML, and more.

Right now, for the third edition, I’m tentatively planning on:

• Expanding the coverage of OOP
• Discussing design patterns
• Demonstrating unit testing
• Walking through some good debugging tools, such as Xdebug
• Introducing the Zend Framework

Other topics that I’m considering are: caching, MongoDB, CVS, Smarty, and doing a new example chapter (presumably using OOP). I also expect that I’ll drop a few chapters whose content is now covered in my other books.

My question, then, is: What would you like to see? Even if you don’t think you’re particularly interested in the book, what do you think is important? What hasn’t been well covered elsewhere (by anyone)? What hasn’t been well covered elsewhere by me?

Any and all ideas, suggestions, and feedback are very much welcome and appreciated!

On the Web => President’s Day Discount at Peachpit.com

Josee pointed out in my forums that Peachpit Press, the publisher of most of my books, is having a big President’s Day sale on their Web site (for those of you around the world, President’s Day is a rather trivial holiday we celebrate in the United States in February, ostensibly to honor our presidents). Peachpit is offering 40% off of any two eBooks or videos or 50% off any three. The coupon code is PRESIDENT. This is also advertised clearly on the front page of Peachpit’s site and ends on February 21. If you’ve been considering some titles, or are thinking about learning something new, this may be the right time.

As an example, looking at my books (because, you know, it’s all about me), the list price for the eBook of “Modern JavaScript: Develop and Design” is $43.99 (all prices in USD). Although the book doesn’t formally come out until February 22nd, it can be pre-ordered. With the 40% discount, that comes down to $26.39. With the 50% discount, that comes down to $22.00. By comparison, the printed book at Amazon is currently selling at $30.99. I will also point out that for international readers, purchasing an eBook will be the fastest way to get a copy, by many months or more (although only in English).

A couple of quick notes: First, I really don’t know much of anything about Peachpit’s site and only found out about this promotion when Josee pointed it out to me. I cannot answer any questions about Peachpit’s site, the e-commerce system there, the types of payments accepted, the policies, and so forth. Second, obviously I get a couple of dollars when you buy a book of mine (normally around $2 per book, depending upon the book) and I do receive an extra $1 more or less when you purchase it at Amazon through the above link. Just want to be transparent about that.

On the Blog => Locale-aware Date and Time Formatting in PHP 5.3

In the third edition of my “PHP and MySQL for Dynamic Web Sites: Visual QuickPro Guide” book, titled “PHP 6 and MySQL 5 for Dynamic Web Sites: Visual QuickPro Guide”, I went out on a limb and used a beta version of PHP 6 when writing the book. PHP 6 was about half-way done at the time, and I didn’t want to complete the book, only to have it be outdated immediately thereafter (using PHP 6 wasn’t, by the way, an attempt to trick the reader into buying the book, as some cynical people have suggested). Well, PHP 6 ended up dying due to many complications and I had the proverbial egg on my face (what Paul rightfully called my “Dewey Defeats Truman” moment). In truth, only about 5% of the book or so required PHP 6, so it wasn’t a devastating mistake, but I certainly felt foolish.

One of the things I wanted to cover in PHP 6 was locale-aware date and time formatting, as part of the goal of PHP 6 was to recognize the more global Web environment. Even though PHP 6 was shelved, the key components have since been integrated into PHP 5.2, 5.3, and the forthcoming 5.4. Locale-aware date and time formatting was demonstrated in the book using the PHP date_format_locale() function. That function went belly-up, and PHP 5.3 now has the IntlDateFormatter class instead. The documentation for the class is poor, but I posted on my blog what I figured out.

Q&A => What are some good general programming books?

Some time back, Richard had sent me an email, saying that it seems like Web developers aren’t quite as up to speed on mainstream programming practices and paradigms. He was hoping for some book recommendations to help improve his own programming skills.

I would agree that because the most common Web-related languages, primarily PHP and JavaScript, are so approachable, they’re easy languages for non-programmers to use. Most people who learn C or Java, do so in a formal environment, obtaining all the fundamental programming theories at the same time. Conversely, many people using PHP, for example, may have no formal programming training, having only learned the language through a well-written book (ahem).

In any case, one should never stop learning, and I sent the following book recommendations back to Richard:

• “The Pragmatic Programmer” by Andrew Hunt and David Thomas
• “The Practice of Programming” by Brian W. Kernighan and Rob Pike
• “The Productive Programmer” by Neal Ford
• “Code Complete” by Steve McConnell

To be clear, I haven’t read all these myself, but they’re all on my short list. In fact, I just started reading “The Pragmatic Programmer” recently (more on that next). But these are the books that I normally come across when I’m looking for books on improving general programming skills. (Also, I’ll get like $1 if you by one of those books through one of those links, just to be completely honest.)

What is Larry Thinking? => Your Knowledge Portfolio

As part of my January-February non-resolutions list, which quickly became my late-February non-resolutions list, I’m catching up on some reading, both work-related and personal. In terms of work, I’ve finally started reading “The Pragmatic Programmer” by Andrew Hunt and David Thomas. I’m not far into it yet, but I am enjoying it. It’s too soon to say what I’ve learned, but I have had some of my own ideas validated, which is worth something, too.

In the very first chapter, there’s a section titled “Your Knowledge Portfolio”, which presents a great perspective on knowledge and learning. In every job, and even more so in IT, what you know is pretty much your value as a worker. This section of “The Pragmatic Programmer” starts off by pointing out that knowledge (and experience) is an expiring asset, meaning it becomes less valuable over time. For example, I used to know how to use HTML frames (not iframes, but classic frames), which isn’t so useful anymore. So “The Pragmatic Programmer” presents an argument for treating your knowledge asset like an investment portfolio. It’s an interesting and novel idea.

This means, for example, that you need to “invest regularly” in your knowledge portfolio and diversify the types of knowledge you acquire. Some should be “high-risk, high-reward”—information that may not pay off but, if it does, will pay off big—and some acquired knowledge should be more conservative. And you should review and rebalance your knowledge portfolio regularly.

The book recommends some specific ways to acquire new knowledge, such as:

• Learn new languages
• Read technical books (ahem)
• Read nontechnical books
• Participate in local user groups

It’s just a very well reasoned, interesting approach to the subject. I certainly see the value of knowledge and continuing to learn new things, but I had never equated this to an investment nor put such an analytic spin on the idea.

This section of the book also has a sidebar (on page 17 of the printed edition) on asking people for help online. It’s a topic that’s solidly on my radar, as I’m usually the one being asked for help (although I do ask others for help, too), and I could not have done a better job of explaining how to most appropriately and effectively ask for help. You can read this snippet through Google books.

So I’m clearly enjoying the book so far and am happy to be finally reading it. No doubt I’ll share more thoughts on it, and some of the other books I’m finally reading, in future newsletters.

Larry Ullman’s Book News => “Modern JavaScript: Develop and Design” Coming Soon!

I am very, very happy to say that my latest book, “Modern JavaScript: Develop and Design”, is at the printer and is slated for a late February release (in the US, although Amazon now has it as March 3rd). Because of the increased page count (624 pages), the price of the book was raised $5.00, to $54.99 (MSRP). However, it seems that Amazon only raised its price like 50 cents. Amazon is currently selling it at $31.00 (US).

I’ve also completed the supporting videos for the book, which will be made available through the publisher’s Web site and in some electronic versions of the book. And I’ve written three supporting articles, that will be published at Peachpit.com.

For the first time ever, I plan on selling copies of select books myself. The books will, of course, be signed (inscribed however you want). For the “Modern JavaScript: Develop and Design” book, I will be able to offer it at $40 (US), plus shipping. This is more than the Amazon price, but I have more overhead (well, different overhead) and fewer employees than Amazon! Plus, Amazon has that whole “economies of scale” thing working for it. I’ll get the e-commerce system setup in the next couple of weeks for purchasing the book through me. If you have any questions or comments, let me know. Along with the eBook version, mentioned earlier, buying the book directly from me will be the fastest way for international recipients to get a copy, by far. I’ll need to receive my copies of the book before I can estimate the shipping costs.

One is the HTML5 Boilerplate, which just came out in version 3. This is a fully-loaded template that includes key JavaScript libraries (Modernizr, jQuery, and Google Analytics), caching recommendations, server configuration, and more. You can download the template in a well-documented format, a bare-bones file, or a custom creation based upon your desired needs.

Very similar is the HTML5 Reset. It also includes Modernizr, jQuery, and Google Analytics, along with a CSS reset, but doesn’t get into the server-side configuration, caching, and such. It’s also available in a corresponding blank WordPress theme, which I’m likely to use as the basis of my next site redesign.

Even if you don’t need to use an HTML5 reset template yourself, you can learn a lot about creating a well-constructed HTML template from  these. A lot of very smart people put quite a bit of thought into the ideas and functionality expressed in the templates. In sum, both represent the current best of the best practices, considering CSS3, jQuery, HTML5, meta tags, SEO, etc., etc.

I started this blog a couple of years ago as a way to support my books and to connect with readers more directly. I hadn’t put much thought or planning into the blog, and have been mostly winging it thus far. Eventually I noticed that the blog was the only part of my site being updated within any regularity, and so I moved the blog to the forefront. When I did that, I also added the Amazon carousel widget as a way to promote my books (it just about covers the cost of hosting, which is a start). The blog had picked up significant viewership because of the popularity of my series on the Yii framework, and I wanted to tap into that (i.e., if you like my writing with this series, you may like one of my books). And now, about a year and half later, I thought it time to put a bit more thought into it.

I’ve been reading many good pieces of advice in the Technical Blogging book, and one that I’ve started implementing already is a harder blogging schedule. Historically, I’ve posted three days a week: Tuesday, Thursday, and the weekend, hopefully not skipping more than one of those days every two weeks (i.e., my goal was to do at least 5 posts in a two-week period). The book makes a good argument for posting on weekdays and for being consistent in the time of day. So as of this month, I’ve started trying to consistently post Monday, Wednesday, and Friday, around 10:30AM (EST). Mostly this means that I’m still writing a blog post on Tuesday, Thursday, and the weekend, but those don’t go live until Monday, Wednesday, and Friday. Same requirement to me, but a consistent end result this way.

Another concept take from the book that I’ve started implementing is a schedule as to the types of posts being made. Almost all of the posts I write fall into one of three categories:

• About me (book updates, newsletters, and the like)
• How-to’s (technical instruction)
• Sharing links and resources

Starting this month, Mondays are for the first type of post, Wednesdays, the second, and Fridays, the third. The thinking is that on Monday morning, you, the lovely reader, will find out what I’m up to, without taking too much time from your other Monday-morning duties. On Friday, you’ll be introduced to something useful, while your work week is winding down. And on Wednesday, in the middle of the week, you’ll see some actual code and perhaps learn how to do something new. That’s the thinking, anyway. This intended schedule also forces me to write more How-to’s, which are more time consuming than the other two types but arguably more useful to readers.

I’m thinking about adding guest posts, book reviews, and other new types of posts. Once I do those, they’ll probably be “one-off” postings that go on Tuesdays and Thursdays.

Through these and other planned changes, I hope to fulfill the two goals that I’ve finally identified for the site:

1. Say something useful (such as my Yii series)
2. Sell a few more books

I do get many specific requests for things people would like to see me write about. If you have any comments or suggestions, I’d love to hear them!

The second resource is a presentation titled JavaScript “Best Practices” (again, the quotation marks), by Christian Heilmann. Heilmann presents about 20 specific suggestions and then explains them all in detail. The presentation itself lacks pretty much any style whatsoever, but content is more important, no? There’s lots of code in the presentation precisely demonstrating both good and bad behaviors, along with explanations as to why something is problematic.

I’m in the process of writing my own article, titled “The 10 Best JavaScript Development and Design Habits”, to be published at Peachpit.com. I’ll post a link to that when it goes online.

One of the things I wanted to cover in PHP 6 was locale-aware date and time formatting, as part of the goal of PHP 6 was to recognize the more global Web environment. Even though PHP 6 was shelved, the key components have since been integrated into PHP 5.2, 5.3, and the forthcoming 5.4. Locale-aware date and time formatting was demonstrated in the book using the PHP 6 date_format_locale() function. That function went belly-up, and PHP 5.3 now has the IntlDateFormatter class instead. The documentation for the class in poor, but here’s what I figured out…

First, let’s look at the original script, Script 14.5, locales.php:

// Set the default timezone:
date_default_timezone_set('UTC');

// Need a date object:
$d = new DateTime();

// Create a list of locales:
$locales = array('en_US', 'fr_FR', 'es_BO', 'zh_Hans_CN', 'ru_RU', 'el_GR', 'is_IS');

// Print the date in each locale:
foreach ($locales as $locale) {

    // Set the locale:
    locale_set_default($locale);

    // Print the date:
    echo "<p>$locale: " . strtotitle(date_format_locale($d, 'l, j F Y')) . "</p>\n";

}

To convert this to work with the IntlDateFormatter class in PHP 5.3, the list of locales must first be changed to use hyphens instead of underscores:

$locales = array('en-US', 'fr-FR', 'es-BO', 'zh-Hans-CN', 'ru-RU', 'el-GR', 'is-IS');

Then, the code for setting the local and formatting the date using that locale (both lines within the loop) have to be changed. As with many things in PHP, you can use the IntlDateFormatter class as an object or procedurally. Let’s look at the procedural approach first, which is what the book also does.

The first step is to create an IntDateFormatter object, using datefmt_create(). Its first argument is the locale. Its next two arguments, both of which are required, are constants representing the date format and the time format. Those constants are listed in the manual. Here’s the complete function call, which would go first within the loop:

$fmt = datefmt_create($locale, IntlDateFormatter::LONG, IntlDateFormatter::SHORT);

That variable will be used as the first argument in the datefmt_format() function. The second argument to the function is the date and time, represented as a DateTime object:

echo "<p>$locale: " . datefmt_format($fmt, $d) . "</p>\n";

Here is the resulting output:

The date and time represented using different locales.

To do the same thing using OOP, you would write:

$ftm = new IntlDateFormatter($locale, IntlDateFormatter::LONG, IntlDateFormatter::SHORT);

$ftm->format($d);

And there you have it!

For the first time ever, I plan on selling copies of select books myself. The books will, of course, be signed (inscribed however you want). For the Modern JavaScript: Develop and Design book, I believe I will be able to offer it at $35 $40 (US), plus shipping. This is slightly more than the Amazon price, but I have more overhead (well, different overhead) and fewer employees than Amazon! Plus, Amazon has that whole “economies of scale” thing working for it. I’ll confirm the price and get the e-commerce system setup in the next couple of weeks. If you have any questions or comments, let me know.

ADDITION: Presumably, the book will be available internationally in time, starting with English-language countries such as Canada, the UK, and Australia, followed by translations in other European countries and Asia (that’s my educated guess, based upon how things have gone in the past). Buying the book directly from me will be the fastest way for international recipients to get a copy, by far. I’ll need to receive my copies of the book before I can estimate the shipping costs.

UPDATE: I just heard back from my contact at the publisher and it will cost me more than I had thought to purchase the book for resale. In order to cover my costs, I’ll need to charge $40 (US) plus shipping. Admittedly, this is almost $10 more than Amazon, but the $40 covers the cost of: the book itself, getting the book shipped to me, and packing materials. I think shipping within the United States via media rate will be around $4.

I had specifically wanted to discuss PHP 6 because of its intended support for Unicode, which is what the code in the book requires for a couple of examples. Even though PHP 6 was shelved, the key components have since been integrated into PHP 5.2, 5.3, and the forthcoming 5.4. Transliteration, the ability to convert text from one alphabet to another, was demonstrated in the book using the PHP 6 str_transliterate() function. That function went belly-up, and PHP 5.4 now has the Transliterator class instead. The documentation for the class in non-existent, but here’s what I figured out…

As with many things in PHP, you can use the Transliterator class as an object or procedurally. Let’s look at the procedural approach first, which is what the book also does. The function that does all the work is transliterator_transliterate(). Its first argument is a either a string identifying the transliteration to conduct, or a Transliterator object. Its second argument is the text to be transliterated.

In the Transliterator class, transliterators are defined using the syntax from-to. So Bengali-Tamil will transliterate from the Bengali alphabet to the Tamil alphabet. Keep in mind this is just the replacing of characters from one alphabet to the corresponding characters in another. This is not translation!

To get the list of possible transliterators, invoke the transliterator_list_ids() method (Figure 1):

echo '<pre>' . print_r(transliterator_list_ids(), 1) . '</pre>';

Figure 1

Returning to the code in the book, in Script 14.4, trans.php, my name using the Latin alphabet was stored in a variable called $me. Then, an array of destination alphabets was created:

$me = 'Larry Ullman';
$scripts = array('Greek', 'Cyrillic', 'Hebrew', 'Arabic', 'Hangul');

Next, a for loop iterated through the array. Within the array, originally, the str_transliterate() function was called:

foreach ($scripts as $script) {
    echo "$me is " . str_transliterate($me, 'Latin', $script) . " in $script.\n";
}

With the updated Transliterator class, the proper syntax is now (Figure 2):

echo "$me is " . transliterator_transliterate ("Latin-$script", $me) . " in $script.\n";

And that’s all there is to it! (To reiterate, this does require PHP 5.4 or greater.)

Figure 2

To do the same thing using object-oriented programming, you’d first create a new Transliterator object:

$t = Transliterator::create("Latin-$script");

Then you call the transliterate() method of the object, providing the text to transliterate as the first argument:

$t->transliterate($me);

And there you have it!

The Transliterator class can be told to transliterate forwards, or in reverse, allowing you to go from an alphabet written in one language to an alphabet written in another.

• What Were You Thinking? => Bimonthly Newsletters
• On the Web => Security and Privacy Made Simpler
• On the Blog => My January 2012 Non-Resolutions List
• Q&A => How do you go about designing the main OOP classes for a project?
• Larry Ullman’s Book News => “Modern Javascript: Develop and Design” Done!

What Were You Thinking? => Bimonthly Newsletters

In the previous newsletter, I asked for input on the idea of changing the newsletter from going out every 3-4 weeks but being longer to going out every 2 weeks but being shorter. You were also able to vote in an online poll. About two-thirds of the votes were for the change, although the more passionate responses were against the change, as those recipients already felt they received too many newsletters and emails. I think what I’m going to do, as a happy medium, is to shoot for a schedule where the newsletters come out slightly faster, like every 2-3 weeks, and are slightly shorter. This should be feasible for me to pull off without overwhelming you.

Towards that end, you may note that there’s no “What is Larry Thinking?” section in this particular newsletter. With the new plan for the newsletter, I’m not going to be quite so rigid about what goes into each newsletter, limiting myself to just five or so significant pieces. The bulk of this newsletter answers a question on OOP design.

My thanks to everyone for their input. And please always feel free to provide any feedback, questions, comments, etc., that you may have. (Postscript: Several of you rightfully pointed out that I misused “biweekly” in the text of the newsletter, despite correctly using “bimonthly” in the heading. I indeed meant “bimonthly”, although “biweekly” has the same inexactitude in that it can mean both every two weeks and twice a week.)

On the Web => Security and Privacy Made Simpler

When I was writing my Effortless E-Commerce with PHP and MySQL book, I naturally did a bunch of research, particularly with regards to the various laws that apply. Understanding the programming behind an e-commerce site is relatively simple; understanding all the applicable laws and implications of doing e-commerce is complex. One of the sites I found to be quite useful was the United States Better Business Bureau (BBB).

I’m currently going through some items in my “to read” folder, and am reading, or perhaps re-reading, the Better Business Bureau’s PDF titled “Security & Privacy – Made Simpler. If you do any e-commerce, or even just Web development, in the U.S. or not, it’s worth your time. It’s a 22-page document that discusses almost every facet of e-commerce, such as:

• Developing a security and privacy plan
• Creating and communicating your security and privacy policies
• Good employee screening and policies
• Common hack/theft strategies
• General Internet security
• Proper handling of customer data
• Payment processing
• What to do in the event of a data breach
• A preview of international e-commerce considerations

The document also has many resources listed in these and other categories. You can download the PDF from that page, but there are also related FAQs and more on the BBB’s site.

On the Blog => My January 2012 Non-Resolutions List

I’ve never been much of a New Year’s Resolution person: if something is important enough to do, start today, not on some arbitrary date that happens to be the first day of the year. (Or, you know, January 2nd, because the first is a holiday and all.) But this year I happen to have quite a long non-resolutions list. The timing is entirely coincidental: I just happen to be done with my “Modern JavaScript: Develop and Design” book around this time, and I always have a long list of things to do between books. I recently posted on my blog about my immediate plans (aka, my non-resolutions list).

Q&A => How do you go about designing the main OOP classes for a project?

While “diving into” Object-Oriented Programming development in PHP, Chris had emailed me about how one sets up the core classes for an OOP-based site. The specific example—user management with login/logout, roles, etc.—is common and not complex, but Chris didn’t know where to start. In my opinion, OOP is easy enough to use once the classes have been defined; the difficulties arise from coming up with the proper classes in the first place. So let’s look at that process, in the abstract.

Programming is a matter of taking actions with data. In a linguistic sense, it’s very much a noun-verb relationship: the user submits form data to a server; the server stores data in a database; the user requests another page; the server pulls data from a database. Whether you’re using OOP or procedural code, you need to identify both the actions and the data first. What are all the verbs that the user or Web site needs to be able to do? What are all the nouns that will be involved in those actions? Once you’ve identified those attributes of the site, procedural programming focuses first on the verbs, OOP focuses first on the nouns.

To start designing OOP classes, one must first organize the types of data the site will work with, in detail. In a user management system, there’s one obvious noun: a User. The properties of a User include: userId, username, userPass, userRole, dateRegistered, and so forth. (Conventionally, OOP uses camel-case for variable and property names.) When you think you’ve identified the nouns involved, go back and see if all of the actions now have the data that needs to be involved. When a new person registers, a User is created (as both a PHP variable and a record in the database). When a person logs in, a User is retrieved from the database and created as a PHP variable. When a person logs out, the User PHP variable can be destroyed. To see if a person has authority to do X, you’d check the User->userRole property.

In some situations, there will be nouns with overlapping roles and properties, which would suggest that you should create a hierarchy of classes. I think of shapes as being the easiest example to comprehend. All two-dimensional shapes have some common attributes, such as area and perimeter, but triangles have three sides, rectangles have four, and circles have none (but do have a radius). When you find yourself in situations like this, you’ll want to design one master class, in this case, Shape, which you never create instances of. Then you define derived classes—Triangle, Rectangle, and Circle—that you would create instances of. Admittedly, knowing when to create a hierarchy can be tough. You might think with a user roles situation that you’d want common users and administrators as two separate classes, but the only difference between the two types is in what actions each can take, which is easily managed using Access Control Lists (ACLs) or the like. Or, put another way, everything about the two users is exactly the same except for the type, so there’s no need to create separate classes (unlike, by comparison, circles and triangles that have some overlapping properties but other very different ones).

Another common class to use on a site would be one for interacting with the database. You could create your own class for this purpose, or just use the MySQLi object or PDO or the like.

Even in a simple site with content and users, there are other clear nouns: the pages of content. Going back to the language analogy, there are some sentences that have a single noun—Johnny runs or A User logs out—but many have more than one noun—Johnny reads a book or A User views a page of content. The content, then, would also be represented by one or more classes, depending upon the variety in the content displayed. If the content is just information displayed within a template of HTML, then Content might have these attributes: contentId, title, body, createdBy, dateCreated, and dateUpdated. The createdBy could be as simple as a userID integer, or more formally be an actual User instance.

Depending upon how OOP-y you want to be, you may also create classes for generating the HTML pages (i.e., View classes) and for handling actions (i.e., Controller classes). Those move you into the realm of a true MVC architecture, which isn’t always necessary, though.

In asking the question, Chris didn’t originally know how to handle the logging in and logging out and registration and such, not knowing if one makes classes for those. Those are actions performed on, or using, objects, and don’t get represented as classes themselves.

Because I’m going to be writing the third edition of my “PHP 5 Advanced: Visual QuickPro Guide” this year, I expect I’ll be doing a lot of writing on the subject of OOP, design patterns, and the like. If anyone has any more questions or comments regarding these topics, let me know.

Larry Ullman’s Book News => “Modern Javascript: Develop and Design” Done!

I am very, very happy to say that my latest book, “Modern JavaScript: Develop and Design”, is officially done. Like done, done. Last week Monday, I submitted the last chapter to be written, Chapter 13, Frameworks. In it, I quickly discuss how to choose a framework, when you should use a framework, and some common libraries (as a framework alternative). The bulk of the chapter introduces and uses jQuery and the Yahoo! User Interface (YUI) Library. For both I explain how to perform common tasks—selecting DOM elements, DOM manipulation, event handling, and Ajax, and then walk through more advanced examples. For both, the chapter explains an autocomplete example, using a PHP script as the data source. For jQuery, I also discuss the DataTables plug-in. For YUI, I also discuss and demonstrate the Yahoo! Query Language (YQL). For it, I go through a couple of examples, including fetching a weather report and a stock quote. (For the record, I specifically target YUI3, which is an improvement over YUI1 and 2, even if some of the framework is currently in beta.)

Chapter 13 is the first chapter in Part 3 of the book, Next Steps. I already wrote Chapter 14, Advanced JavaScript, which has a heavy focus on closures. Chapter 15, A PHP and JavaScript Example, creates a pseudo-complete auction system. Auctions are set to expire on a certain date and time. Logged-in users can bid on items. All dates and times are shown using Coordinated Universal Time (UTC) or the user’s timezone, if the user is logged-in. Then, JavaScript used to enhance the experience. This includes using Ajax for the login and bid forms, retrieving the latest bids via Ajax (and updating the table of bids with them), and creating countdown timers that show the amount of time left in an auction, when that’s less than an hour. I think the chapter turned out well, and it emphasizes the various ways to pass data back and forth between PHP and JavaScript, a common point of confusion.

Not only is all of the initial writing is complete, but I’ve also done the rewrites on the entire book, and I just—moments ago—finished reviewing the PDF layouts, which is the last step before the book goes to the printer. (As you can tell, there are a lot of overlapping steps here at the end.) I believe the book will still ship, as originally planned, at the end of February.

In support of the book, I’ll also be writing a couple of articles (published online for free) and create some screencasts (to be provided in various places).