I’ve been exceptionally busy at work, we’re beginning to finish up a much needed, much discussed by librarians, redesign of PubMed.  We’ve put a ton of user interaction effort into this project, as well as a good sprinkling of graphic design (watch out, I even did some parts!)  I think people will be really positive about these new changes.

[Just for the record, if someone happens to stumble upon this from the librarian community, yes, release date is still end of summer, and yes, there will be a Beta period, so no need to worry about a short timeline to update your class or instructional slides.  We do listen!]

It’s also been exciting that we’ve brought a few new people on board.  Always exciting to have new hires, despite the fact that it’s a lot of work… and all of the trainings I have to do.

What else…  I’m planning on attending the DelveUI masterclasses this week in Brooklyn.  It will be interesting to see what some of the heads of state have to say about the field.  I’m a little excited, this masterclass format isn’t the usual boring no-content fluff that you hear at most conferences. I get the feeling that there will actually be code present!  My thanks to the lovely Jina “Sushi & Robots” Bolton for the opportunity for the free ticket.

I’ve been reading… way too many things.  I’ve been reading Learning jQuery 1.3, jQuery UI 1.6, and jQuery in Action and you’ll see the reviews of those two books very soon.  (Can you tell that we’ve switched to jQuery at NCBI?)  I’m a little behind with that reading, but I’ve been working hard on other things.  Additionally, I went on an Amazon spree, and started reading Programming the Semantic Web, An Introduction to Lambda Calculi for Computer Scientists, To Mock a Mockingbird, 101 Things I learned in Architecture School, Code Complete 2.   Last but not least, I’ve also been reading any photography book that I can get my hands on.

Yes, that is a lot of books, and I haven’t had much time for them.  I’ve been working hard at work, and I want to relax a bit when I come home.  Once summer ends, things will return to a slightly more regular pace.  I’ve been learning so much on the job, that I’m not very worried about falling behind in reading.

It’s the summer, so I have been riding… not a ton, but some.  I wish I had time to do more, but I don’t have time for everything.  I have been taking long-ish 7 mile rides home, and then going out to play some basketball with my roommates.  That’s a good time.  As soon as I finish this post, I am going to go and fix my fixie… my favorite Bianchi… I somehow mashed the pedals hard enough to shear off part of the thread of both the crank and the pedal, so there go the original cranks and some lovely MKS Sylvan Track Pedals that were on there. I’ve got a new, generic replacement crankset and new Sylvan’s.  Also, I’m moving from a 42×15 to a 46×17, but with the change in crank length (172.5 down to 165mm) I’ll have the same gear ratio as before.  I’m interested in seeing how the shorter cranks feel.

Not to mention le Tour this year… I was captivated.

And then I’ve been taking some photos.  Still have been good on my New Year’s resolution of taking a photo every day… with the exception of Jan 20 (yes, Inauguration Day, the day more people in my Washington DC area took photos than any other this year).

I also got an iPhone.  While I was in California for Joel and Olga’s wedding, I dropped my phone of more than 5 years on a rug, and the antenna that had been barely holding on for a few months finally fell off completely.  I had previously told myself that I would try to wait until my phone broke before getting a new one. So I was going to buy one at the first sight of antenna problems, until it was suggested that I wait for a new version.  Well, my phone’s demise and the new version’s release coincided, so now I have a 3GS.  Really the thing I like most is having my calendar with me at all times.  The only other part I really like is the speaker, so I can listen to music while on my bike for the first time.

Alright, so that’s about that for the moment. Go out and do something summer-y, that’s what I’m doing.

I ran across a mention of “Prototype-Based Programming” back when I was first learning JavaScript.  I thought it would be an interesting read, but forgot to bookmark it, and forgot to look into it further.  Once I finally remembered it, it proved hard to find (and an expensive gamble from Amazon), until I found it through NIH’s interlibrary loan system.

I was quite excited to get my hands on a copy of this book, I was interested in learning more about the general theory that went into languages with prototypal inheritance.  I thought this would allow me a special insight into JavaScript.  However, as I found reading it… despite it’s 1999 publication date, JavaScript wasn’t even mentioned in the book!  Regardless, I found parts of it to be quite interesting and insightful.

The book is broken up into three sections (as mentioned on the cover), Concepts, Languages, and Applications.  Each section has 4 associated chapters which are really various papers, some of which seem to be difficult to find elsewhere.

The first section, “Concepts” was the most interesting. The first was titled “Classes vs. Prototypes: Some Philosophical and Historical Observations.”  This chapter provided a nice introduction to the topic, including the history of classification, going back to Aristotle and proceeding to Ludwig Wittgenstein who had an interesting example about classifying the characteristics of an item as simple as a “game”.  It goes on to transition to a programming perspective.  A point that is made repeatedly throughout many chapters that the idea of classical inheritance necessitating construction from the top (superclasses) to the bottom (subclasses) is inherently contradictory to the way humans think.  When unfamiliar with a domain, a person can more easily deal with concrete examples, and only discern the abstract general form after discovering these patterns in the concrete cases.  Though unable to put my finger on this idea, I’ve experienced it a number of times when programming myself, and couldn’t agree more.

The next chapter, “Classifying Prototype-based Programming Languages” sought to categorize the theoritical aspects of different prototypal languages.  This is the chapter where I most missed the reference to JavaScript, but I may look into doing that myself some other day.  “The Stripetalk Papers: Understandability as a Language Design Issue in Object-Oriented Programming Systems”, made an argument that prototype based systems could be used to enhance the learnability of languages.  Finally, the chapter “Classes versus Prototypes in Object-Oriented Languages” looked at the advantages and disadvantages of class-based and prototype-based languages.  This chapter was quite interesting, however brief.

The second section, “Languages”, lacking JavaScript, was less useful than I had hoped.  “Programming as an Experience: The Inspiration for Self” was interesting as it described the thought process going into creating the Self language, and expanded some of the ideas presented in the book’s second chapter.  Alas, I’ve haven’t yet gotten around to learning Self, but the ideas and history presented were interesting in the abstract.  “NewtonScript: Prototypes on the Palm” was interesting mostly because of it’s Lisp-like syntax and it’s description of internal closures, while “The Prototype-Instance Object Systems in Amulet and Garnet” took an in-depth look at the implementation of these two languages.  I only skimmed the “Omega: Statically Typed Prototypes” chapter, as it was rather brief, and I don’t feel confident enough (or have any real desire) to enter the static-typed/dynamic-typed languages argument.

The final section, “Applications”, was where this book showed it’s age.  “Self includes: Smalltalk” involved translating Smalltalk programs into Self, which is interesting, but I don’t see much practical application for this today (maybe if you’re translating Ruby to JavaScript? Not sure).  “Using Prototypes for Program Restructuring” demonstrated the use of an algorithm that would help to restructure code into a slot-based prototype system in a application called Guru.  “Prototype-Based Programming for Abstract Program Visualisation” ended up being skimmed, because while the topic matter seemed interesting, the demonstrations from the black-and-white mac era looked totally antiquated, and I am sure that they have been written many times in other languages since the writing.  Finally, “Agora: The Scheme of Object-Orientation, or, the Simplest MOP in the World” detailed the Agora language, a pure OO language which relied only on objects and message passing, while being implemented as a reflective language inspired by Scheme, of all things. Weird, but interesting.

You know as well as I do that computer technology is a moving target, and something published in 1999 will be outdated to a certain degree.  The good part of this book is that the abstract notions in it are rather timeless, as they have been built on over time.  Parts of this book may be out of date, but parts aren’t, and regardless, it’s an interesting read.  I recommend it, if you’re even slightly interested.

Based on the title, Expert Python Programming, (by Tarek Ziadé) I had expected a book covering the Python language… syntax, advanced data structures, maybe some functional programming… stuff like that. This book surprised me. Rather, it contains a hodgepodge of information about the world of Python development, from setting up editors to distributed version control to application distribution. “Expert Python Programming” does contain some information on the Python language itself, but not as much as I would have hoped. While it does contain a good amount of useful information, overall, I’d have to say that it misses the target.

Quickly summarized, the book contains 3 chapters on package management and distribution, 2 on syntax, 2 on optimization, and one each on language setup, naming conventions (style guide), version control, project management, documentation, test-driven development, and design patterns. Based on the content, I might have titled this book “Expert Python Development Practices”, and think I would have been happier reading it in that case. The discrepancy between the title and the content is especially bothersome to me, since it would be easy to assume this book focused specifically on programming, rather than code management.

Expert Python Programming’s greatest asset is the number of tools and utilities that it covers. As a mostly casual Python programmer, there were a number of things that I learned, especially with regard to package management and distribution. I’ve never needed to build a package, and never used Atomisator or zc.buildout before, so I found these chapters rather interesting (though not personally useful at the moment). To be sure, when I need to use these, this book will the be the first place I come.

I was familiar with a decent amount of the information in the documentation, test-driven development, and style-guide chapters from reading some of the Python Documentation and a few of the PEPs (Python Enahncement Proposals). These chapters would be good for anyone who doesn’t want to have to go and search for this information on their own, and I think it would be rather handy to have all of this information in one place.

The weakest part of the book were the chapters focusing on Python itself. The majority wasn’t anything particularly groundbreaking here that I haven’t read elsewhere, while the interesting sections, such as “How Python Deals with Memory” and “Multithreading” were short and not particularly detailed. The sections on optimization were nice, but limited.

My only other observations were that the Mr. Ziadé at times made statements of opinions that he presented as fact. I would have preferred him presenting code as evidence towards these opinions and leaving the reader to decide for themselves. To be fair, these moments were infrequent enough that they weren’t that bothersome.

Through no fault of the author, Packt Publishing did let a number of small editorial mistakes slip through. Additionally, I found myself often wanting a better presentation of code samples. The overall design of the code examples and body text of the book ended up being quite similar, and I wish that they had made a bigger differential between the two.

Personally, I was disappointed that the Expert Python Programming’s didn’t feature aspects about the language as prominently as the everything else. I can only recommend that any potential buyers of this book borrow a copy, or make a trip to the local bookstore to flip through it first. Otherwise, this may not be the book that you were looking for.

I recently read Object-Oriented JavaScript, by Stoyan Stefanov. In reviewing it, I found it was one of the most interesting books I’ve read in a while, for some good reasons and a few more curious reasons.

Object-Oriented JavaScript was authored by Mr. Stefanov, who is a developer at Yahoo. It features an impressive number of reviewers (twelve), among them Douglas Crockford, the author of JavaScript: The Good Parts, and Ross Harmes, author of JavaScript Design Patterns, both of whom are Stefanov’s Yahoo co-workers. In a reasonable 330 pages, it features eight chapters on JavaScript’s History, Basic Syntax/Features, Functions, Objects, Prototypes, Inheritance, the DOM, and Patterns/Best Practices.

Readers with little to no JavaScript knowledge will be able to read this book, but I’m uncertain how much they’ll be able to glean from the meaty inner chapters (functions, objects, prototypes, and inheritance). Readers with moderate JavaScript understanding should be able to learn a great deal from this book. At the very least, advanced readers should be reminded of some of the language’s quirkier parts, as well as benefiting from an organized chapter on inheritance techniques.

It is tricky placing Object-Oriented JavaScript in context of the corpus of JavaScript literature. This book includes more than a little introductory material (chapters 1-2), while the core chapters (3-6) are way beyond an introduction. Only after those chapters (which I will discuss in a second) is the reader introduced briefly to the DOM and XHR before a chapter on design patterns and best practices. At a minimum, every chapter is useful and full of hints that are difficult to grep from run-of-the-mill JavaScript books. The book steers clear of the murky world of browser differences unless they’re pertinent to the topic of Object-Oriented JavaScript, which seems perfectly acceptable.

Back to those middle chapters, they are sheer gold. I am going force myself to make time to re-read this book, if not those chapters alone. They present, in a clear and organized fashion, many difficult aspects of the language, including closures, prototype, and 12 different methods for inheritance. In comparison, I believe Harmes’ book isn’t as well organized, and Crockford’s book isn’t as clear. Stefanov doesn’t break much new ground here, but the clarity describing these techniques is quite valuable regardless.

Object-Oriented JavaScript appears occasionally try to be something to everyone. This is kind of disappointing, since I would have loved to have seen any additional discussion or insight the author could have offered in the core chapters. There are tons of introductory JavaScript books, so I don’t know what a book titled Object-Oriented JavaScript gains by including more introduction. This shouldn’t detract from the book’s overall value. All of the chapters are well written and useful. However as a reader gains a better understanding of JavaScript, the introductory chapters will become far less useful, while the other chapters will remain an excellent reference.

In my mind, the three best JavaScript books are Flanagan’s JavaScript The Definitive Guide, Crockford’s JavaScript: The Good Parts, and Harmes’ and [Dustin] Diaz’s Pro JavaScript Design Patterns. Object-Oriented JavaScript doesn’t belong in that company for the reasons mentioned above. However, I would easily give it fourth place, and recommend it as a clear description of JavaScript’s harder parts.

“Forms suck.  If you don’t believe me, try to find people who like filling them in.”

Are you kidding, I paid for a book that begins like that?  My first reaction was that I could have written that!  Well I didn’t write it, and I also feel that I got my money’s worth out of Web Form Design, Filling in the Blanks, by Luke Wroblewski.

Forms are hard.  I don’t think I need to mention how hard they can be for users… nor do I need to mention what’s at stake if a user finds your form too difficult.  Every web developer who doesn’t have his/her head in the clouds should know that.  Forms, however, are also very difficult to create… correctly!  A well designed form requires a lot of careful, detailed thought.  You have so much to consider… usability issues, accessibility issues, and you usually don’t have anything to go on except for your personal experience.  This book will help you methodically approach form design, and give you the experience of an expert to guide your decisions.

Web Form Design is useful, because Mr. Wroblewski takes a very detailed approach to each aspect of form design.  Within each chapter, he thoroughly analyzes the major elements to consider when designing a form.   For example, the chapter on “Actions” is devoted to action items such as submit and cancel buttons.  One of the sub-sections discusses where to place these items on the page.  The author first presents the reader with the following image demonstrating all of the reasonable placements for the submit and cancel actions.

Using eye-tracking and usability data, he then discusses the pros and cons of each arrangement, without ever deciding one is better then all others.  This is key because it lets the reader, knowledge in hand, decide his/her own course of action.

The book is especially valuable because of the user data, eye-tracking data, and case studies presented within. Mr. Wroblewski’s backs his reasoning with either a summary of these tests or with an example culled from his experiences.  He reinforces his points with a number of demonstration images, all available from the book’s flickr page.  Then he includes a short “best practices” section to close each chapter, outlining what was discussed.  These can be used almost as checklists.  Interspersed in the text are sidebars which present real-life examples and perspectives from numerous field authorities.

Web Form Design is written well enough so that it can be easily read within a few hours.  However, it’s real place is beside you the next time that you have to design or write a form, so that you will be able to make intelligent design decisions, rather than just best guesses.

My favorite books are mostly at the top (actually, there’s no rhyme or reason to any of it).  Just looking, I realize that there are a bunch of Ruby books that I almost never look at. The orange book behind the wire on the top shelf is a really good Dover book on Graph Theory.

My monitor setup.  I’ve got 3 computers, the laptop, my ‘frankenmac’ desktop, and a pc.  The frankenmac is dying, so I am probably going to have to shift things around.  I don’t have a plan for which computer will go with which monitor, but the desk is now set, and won’t change.  I’ve got my new Griffin Elevator sitting there.  I’m happy with it, keeps the bottom of the laptop really cool.

Anyway, it’s been a week… let’s see how clean I can keep it.

The book’s subtitle, “A beginner’s tutorial to building web applications, quickly and cleanly, with the Django application framework,” frames the book perfectly.  Its target audience is programmers (moderately) familiar with Python, but who are, at the same time, new to Django.  The book is really focused towards this audience.  The other key word in the subtitle is “quickly.”  This book moves along in a hurry while creating the demonstration app.  I was quite comfortable (and pleased) by the pace, however, I can imagine that a more novice programmer may have a harder time dealing with the information flying by.

The book centers on building one app, a social bookmarking website similar to del.icio.us, or ma.gnolia.  I think type of site was a good choice, since it provides the author with a varying degree of complexity to play around with.  It allowed Mr. Hourieh to start with the basics.  This book succeeds in starting simple and getting harder as it goes along.  I also thought it was good to focus on creating just one website, rather than a bunch of mini-projects or examples, since it models a more real-life situation.  The idea of a social bookmarking website, as well, is very useful because its features are currently en vogue, and can be found on many current sites.

Chapters One and Two are the obligatory “what is Django” and “how to install” chapters.  The meat of the book starts in Chapter Three when the project is introduced.   By the end of this third chapter, we’ve already quickly written three database models (Links, Users, and Bookmarks) and the main page.  Chapter Four introduces Django’s built-in user authentication system (django.contrib.auth), and describes how to write login, logout, and registration pages.  Chapter Five instructs us to write an additional database model (tags), which is more complex than the models we wrote previously.  Here we also write pages to display the list of bookmarks, bookmarks by tags, and a tag cloud.  [To illustrate how fast we're moving, Chapter Five ends on page 91]

Mr. Hourieh adds occasional asides throughout Learning Website Development with Django, such as one on security at the end of Chapter Five.  Personally, I’d have liked to see more of these, but I think he consciously limited the number to better suit the book’s audience.

Chapter Six introduces AJAX behaviors, using the jQuery library.  The author includes a lightning-fast tutorial on jQuery.  The reader is then shown how to implement a live search display, in-place bookmark editing, and a tag auto-complete feature.  Chapter Seven adds both a voting and commenting system to our application.  The user writes a new database model (Shared Bookmark), and shows how to implement comments piggy-backing on Django’s built-in comment system (django.contrib.comments).

In Chapter Eight, we are finally introduced to Django’s built-in Administration Interface (django.contrib.admin), and the reader is shown how to customize the admin pages and deal with user permissions.  Chapter Nine describes adding RSS feeds, Pagination, and advanced search capabilities to our application.  We’re taught how to create advanced model queries using both the objects.filter() function and Q objects to build multi-faceted queries.

Chapter Ten focuses on adding a “Friend” data model to the application.  This chapter demonstrates how Django can be used to send email (friend ‘invites’ in this case), and how the bookmark application can be used to handle activation links.  Chapter Eleven covers three topics; language translation, caching, and unit testing.  None of these are as “flashy” as the previously covered topics, but they are given adequate mention. The final chapter, Chapter Twelve mentions a number of advanced topics that the reader is left to research on his/her own.

The book is generally well written.  I like the structure.  The chapter beginnings outline a plan for implementation, and the remainders proceede step-by-step.  I would have liked the writing to have been polished a little more.  The language seems too formal in places, and when you mix in a number of technical ideas, the language can distract.  This however, may just be a personal preference.

The more I think about Learning Website Development with Django, the more I like it.  It is well suited for someone who wants to get off the ground quickly; someone who needs to get something done and can worry about the details when they need to.  It’s not a bible, but it’s not trying to be, and I think that’s where it really succeeds.

For those who are not familiar with Yslow, it is (again) a plugin for the firebug, the addon for Firefox. It tests a website based on 14 varying rules, from server settings to page construction. There are a few on the list that most people haven’t heard of, yet are rather important (I had never heard of an ETag much less known what to do with one). When Yslow came out, I took a peek at the best practices document which briefly explained each of the rules. I wanted to find out more, so I ordered the book. Unfortunately, High Performance Web Sites let me down for just that reason. I didn’t find out much more.

High Performance Web Sites starts off with a table listing alexa’s top 10 U.S. websites (substituting AOL.com for craigslist.org). Then, 14 chapters (one for each rule) are devoted to explaining the rule, and showing how many of the top 10 are implementing it. The final chapter steps through the 10 websites and shows what they do to reduce the load time of their websites.

My problem was that the book really didn’t offer any new information. Basically, the best practices document was explained in slightly greater depth…but only slightly. I was disappointed to find out that there were very few additional ideas in the book… apparently the 14 rules cover the possibilities of writing faster-loading websites (ahem). The chapter analyzing the ten major websites had a ton of room for furthering ideas, but offered a limited few.

I was most disappointed in the book because I had looked forward to more. The plugin itself, and the list of rules are both terrific. Having a concise set of tests to walk through is extremely valuable. I can not say the same for the book. I hope my money went towards further work, yet I wonder how that’s being filtered through O’Reilly (the publisher) and Yahoo (the official creator of Yslow). I recommend reading the Yslow best practices, and taking a look at the Yslow user guide instead.

That being said, it did seem pretty nice. Looks like little pieces of html/css can be specified for each component you are placing on the page. True to their what I have heard, you can customize everything this way. The downside is it takes a lot of work and planning to customize EVERYTHING. Add to that the {template syntax} and it looks like quite a bit of work. We’ll see how much time I have given all of the other stuff I am working on.

I placed an order today and should receive $200 worth of books from amazon sometime soon. Programming, OOP, design, and typography, and that Microformats book. Those, and the other books sitting on my shelves waiting to be read should be more than enough light reading for a while.