Hard to believe that 2010 is already more than half over. I have three speaking engagements coming up where I’ll be presenting Joomla Development Tools and Tricks. It’s the presentation I originally gave at J! & Beyond as well as JoomlaDay New England.
First, I’ll be at OpenCamp in Dallas on August 27th – 29th (that’s next week!). OpenCamp is targeted at Joomla, Drupal, and WordPress users. There’s a huge lineup of speakers from the CMS community, as well as the general tech community at large. Tickets are still available, so grab them!
Next, JoomlaDay West will be held in San Jose, California October 1-3. They’re still accepting proposals for talks, so get yours in while there’s still time! This one features not only a regular conference and an unconference, but a “hackable” conference where you can either attend sessions or add your own. Sam Moffat and Andrew Eddie will be flying in from Australia, so what’s your excuse for not coming?
Finally, the first ever JoomlaDay DC will take place on October 16th. We have an early bird rate of $49.95 that expires on August 31st, so sign up today! We have speakers from our local NoVA JUG, as well as ones from the East Coast and beyond.
I finally published my HowToJoomla.net tutorial on using Git with Joomla!. I really struggled with trying to balance an introduction to version control, Git, and Joomla specific considerations, but I think the result was worth the time. One thing I would have liked to have covered would have been some of the GUIs that are available for Git, but that seemed to be a bit much for an intro article. By not covering the GUIs, I was able to focus on the core commands that everyone can use regardless of platform.
In any event, my hope is that this introduction will be useful not only to PHP developers, but also to template designers and site administrators. Any time you start writing even a single line of code is the right time to consider using version control as a part of your Joomla! workflow. It’s one of those tools you never knew to ask about; now you don’t have to.
And if you want to see some Git and Joomla in action, don’t miss my talk at OpenCamp. It’s the same one I gave at JoomlaDay New England as well as J! and Beyond, so now Texans will be ‘git’ting too
On the Joomla! Community Blog, Steve Burge is requesting ideas for better communication between the OSM board and the Joomla community. If you are in any way involved in the Joomla community, please take a few moments to share your ideas with the OSM board. I just sent in my ideas and what I wrote is below. While I’m not sure that my ideas are 100% practical, there definitely needs to be better communication of how much money OSM is needing and what the money will be spent on.
Which questions are important enough to undergo community consultation?
OSM should adopt and publish an annual budget at a set time of the year, detailing planned expenses and desired vs. expected revenue.
Any single purchase totaling more than 5% of the annual budget should be put before community review.
Any decisions that involve compensating members of the Joomla community for ongoing services (greater than one month) should also definitely undergo community review. I think there’s potential for favoritism (or at least the accusation of it) if people who are close to the Joomla community are compensated for tasks behind closed doors.
Financially, these policies should make it possible to pay for routine expenses quickly, while ensuring that “back room deals” do not occur. These policies should also appropriately set the expectations for how much OSM will spend and how much it needs to carry out its mission. “More” is not the answer to “how much?”
Any proposals to change the leadership or governing structure of OSM or the Joomla project should go under community review. There have been far too many times where a new structure is simply announced because “the old one was too burdensome.” While this may be true, a new structure may not necessarily be less burdensome.
Changes or adoptions of OSM policies concerning the rights or responsibilities of members of the Joomla community should undergo community review.
What steps should all these decisions go through?
Community review should be the following process:
- Creating a proposal
- Putting the proposal up for vote with the following options: approve, disapprove (no change), disapprove with suggestions for alternative.
- Voting open for one week.
- If the majority of voters approve, the change is made. If the majority of voters disapprove with no suggestions, the issue is dropped. If there is no majority, the suggestions should be considered, then a new proposal should be created.
Ideally, eligible voters should meet a predetermined criteria (n number of posts on the Joomla forms, etc…). In the absence of predetermined criteria, voting should be open to the public at large.
UPDATE 3/26/10: After the discussion below, I’ve been reminded and convinced that a binding vote is not such a good idea. The logistics are tough to sort out when it comes to who is eligible. More importantly, OSM board members are legally liable for their decisions, while members of the Joomla community do not have this liability. Still, I think that having a simple feedback mechanism (let people either “like” an idea or suggest alternatives) for a set period of time would help things.
UPDATE 3/27/10: OSM Treasurer Dave Huelsmann has posted OSM’s unaudited YTD financials. It appears as though this will now be done on a monthly basis. I believe this will go a long way towards communicating OSM’s financial position and needs so that people can assist and rumors can be dismantled. If you’re not familiar with the way balance sheets and P&L statements work, Dave has also posted some helpful links where you can learn about them.
Joomla conference registrations for 2010 are already filling up, are you going? I’m going to be speaking at several of them, so if you want to catch my talk, be sure to make plans to attend.
First, I’ll be at J and Beyond! in Wiesbaden, Germany from May 30th – June 1st. This conference is international in focus; it has already drawn speakers from North America, Europe, and even a remote video presentation from Australia. Check out the proposals and vote on the ones you’re most interested in! Tickets are €99 for the three day event, which is a total steal (even if you have to exchange from another currency ).
Before the end of the week, I’ll be traveling someplace a little closer to home: Vermont. Registrations for Joomla! Day New England (June 5th) just kicked off, so be sure to get your tickets. While I haven’t been to Marlboro, I have been to other places in Vermont and can attest to the state’s natural beauty Having met Elin, Mitch, Andy, Jen, and Barrie, I can confirm that this JoomlaDay is one not to miss!
Finally, preparations for the first JoomlaDay DC are underway. We’re still working out the venue and details, but we’re aiming to hold it on September 18th. Joomla is used in many Federal agencies as well as non-profits, which makes the Washington DC area the perfect place to hold a JoomlaDay. This will be a sponsored event, so email me at firstname.lastname@example.org if you’re interested in spreading the word about your business!
See you in Wiesbaden, Marlboro, or Washington DC!
I have another How To Joomla article up: How to debug our Joomla code with FirePHP. Just recently, I discovered a plugin that painlessly adds FirePHP to your Joomla site. After installing it and doing some tests, I decided to write an article. In the midst of writing the article, I went to the FirePHP wiki and found another FirePHP plugin for Joomla released by the Kunena team. This one is even better, with tighter integration into the Joomla environment. I see many possibilities for model debugging and exception handling down the road.
Drupal and WordPress also have FirePHP plugins, as do most of the major stand-alone PHP frameworks. Have a look to see if your favorite is listed before trying to hack FirePHP into your next project.
Over the past few months, I’ve assembled a set of tools to manage my phone setup. Incidentally, this has increased the quality of my calls and cut down on my monthly expenses. My current monthly cost for all phone usage is now well under $15. All thanks to the following tools:
Last May, I went back into full-time freelancing. With this comes a lot of clients and phone conversations. I wanted to have a phone number I could give out instead of my personal cell number. Fortunately, I got my Google Voice beta invite before the end of the summer. Google Voice gives you a new phone number that forwards to any set of phones you want. It’s set so you can selectively forward calls to individual phones based on who’s calling or on the time of day.
When you want to dial out using your Google Voice number, you go to the Google Voice website, enter the number you want to dial, then select the phone you want to ring. Your phone rings, then the number dials when you pickup. If you don’t want to use the website, you can also call your Google Voice number from one of your phones and then dial the number you want. All calls to US telephone numbers are free.
Google Voice also has voicemail. When voicemail is recorded, it is automatically transcribed into text. You can it so that the transcription automatically goes to your email or gets sent to your phone as a text message. You can also listen to your voicemails through the website and watch them play alongside the transcription.
There are a ton of other features included, but that’s the core of how it works. You can sign up for their beta and wait for an invite, or you can get invites from an existing user (if they have any). Unfortunately, it’s currently limited strictly to the United States: you must have a phone number in a US-based area code for it to work.
Eventually, they will offer number portability so you can use your existing number instead of getting a new one. I initially wanted to wait until this happened so that I could just use my existing number and filter my contacts. However, Google Voice is compelling enough that I’m now giving my new number out instead of my cell.
Skype, Gizmo5, and SIP
In addition to getting a “business” line, I also wanted to have phone conversations without using up daytime cellphone minutes. Additionally, reception in my apartment has proven spotty. My first attempt at moving off the cell involved using Skype. Unlimited incoming and outgoing (US) calls through Skype can be had for $60/year. You get a regular phone number and you can make calls from your computer or smartphone.
Skype can be handy if you’re traveling internationally and want to make calls without roaming, but the call quality is highly variable. Half the time, people could hear me fine; half the time, people said I sounded “choppy” or “computery.” I found that using a headset instead of the speakerphone on my MacBook worked better, but still ran into noticeable quality issues.
Around the time I signed up for Google Voice, I also signed up for a Gizmo5 account. Gizmo works roughly the same way Skype does. At first, I wasn’t too impressed with the audio quality of their desktop software, so I abandoned it. However, when I looked into phone options later, I found a feature that helps you get around the software issue. Gizmo supports Session Initiation Protocol (SIP). You can look up the definition if you want, but the short version is that SIP allows you to hook up any software or hardware to the account. In contrast, Skype forces you to use devices and software specifically designed for Skype.
I first tested Gizmo’s SIP functionality by downloading a simple open-source Mac program called Telephone. Google Voice and Telephone worked pretty well together, but I still had occasional issues with my speakerphone and lags. In an attempt to get around this, I bought an entry level SIP phone. It looks like a regular phone, but it plugs into your router instead of your phone line.
I’ve been using this phone for a couple of weeks now and have not received one complaint about the audio quality. The lag is also less noticeable or non-existent. I’ve only noticed a few minor issues with the phone. Getting it set up was not impossible, but you definitely had to have a good idea of what you were doing. While the connection always stays on while I’m making a phone call, the phone occasionally gets logged out of the server after a day of inactivity. In that case, you just have to unplug it and plug it back in.
Although it feels like a standard desk phone, I can’t dial directly from it without counting against Gizmo minutes (incoming calls are free). Just like other phones connected to Google Voice, I dial my numbers through the website, which then calls my Gizmo account, and then my number is dialed when I pick up.
Shortly after I signed up for my Gizmo account, Google bought Gizmo and promptly shut off new account signups. There’s much speculation that Google with further integrate Gizmo and Google Voice, potentially making dialing seamless.
In all of this, I think the key is dedicated hardware. Regardless of your computer’s speed, it’s still designed to do multiple things at once. Phone software can be tricky to build correctly. When you throw a speakerphone, Bluetooth headset, or WiFi connection into the mix, you’re pretty much asking for trouble. Hardware dedicated for phone calls can focus solely on maintaining the quality of your phone conversation.
It’s possible that Skype-specific hardware would have given me similar results as my SIP phone. If you’re considering a similar setup and SIP sounds like a lot of work, a phone or router designed for Skype might be a viable alternative. However, Google’s acquisition of Gizmo may soon produce something easier to setup.
Years back, prepaid cellphones were expensive; primarily bought by people looking for something to use in case of a dire roadside emergency. That’s now changed. For the longest time, I was on a 300 anytime minutes and unlimited weekend plan for $30/month plus tax. I never came close to exhausting my anytime minutes, but this was the cheapest plan including weekends. Even including my weekend use, my minute usage rarely reached 400. Also, I was being charged an exorbitant $0.20 per incoming and outgoing text message. While it wasn’t really a financial hardship, there was something irritating about paying for minutes I couldn’t use, then being expected to pay extra for something that costs cell phone companies LESS to provide.
I started hearing about T-Mobile’s newer prepaid plans and began doing the math. When I looked into them, it turns out that the versions come down as low as $0.10/minute when you buy $100 worth at a time. Multiply that rate by 300 minutes and we’re back at $30/month.
I made my move when I knew I would be out of the country for a couple of weeks. I was able to switch over to the prepaid plan almost seamlessly with a call to customer service. Same number, same phone. Savings: approximately $340 per year, when including the tax on post-paid accounts.
Being a programmer, some people automatically assume I have either an iPhone, Google Android, or some other smartphone. Actually, it’s a Samsung r225m. If you’re really interested, you can Google it, but everyone else can just rest assured when I say “this is an old phone.” It does phone calls, has an address book, does text messaging, and if I’m getting a little crazy I can turn on AIM. The battery lasts all day, and has been going strong for five and a half years.
However, this doesn’t mean I’ll keep the r225m forever. Since it’s based on GSM, I can take the SIM card out and pop it into a new phone at any time. I’m not interested in signing any new cell phone contract ever again. While it means I’ll end up paying more upfront for handsets, the long-run savings far outweigh the initial cost.
Earlier this week, I made my debut on HowToJoomla.net with an article on How to Fix Joomla Content Plugins. If you’ve used Joomla since the 1.0 days, you may recall that content plugins acted on both articles and Custom HTML modules. In 1.5, this behavior changed so that Content plugins only act on articles from the Article Manager. Fortunately, there are several options for regaining and controlling this functionality, which I outline in the post. Head over and let me know what you think!
When I originally received my copy of the Joomla! 1.5 Development Cookbook, I was in the middle of a large client project. The book sat over on my shelf for a few days waiting to be read. While working on my code, I came to a point where I wanted to add some custom markup to the portion of the HTML document. Although I usually whip out my Joomla Textmate bundle to pull up the right snippet, this wasn’t something I already had preprogrammed and ready to go.
If I learned something, you’ll learn something
I was about to do a Google search, but suddenly remembered that James’ book was in arm’s reach and might have the answer. After turning to the index and finding the topic, I quickly located the exact code I needed to move on. Despite having written a book on Joomla myself, this one came to my rescue at just the right time!
While it took me a while to read all 130 recipes (including time on airplanes, buses, and sitting in my living room), the practical tips and methods were worth it. James covers a wide breadth of Joomla programming topics, matched only by his Joomla Framework reference. Most passages are 2-3 pages long and include relevant information that’s quickly applicable to any Joomla project you’re working on.
Two chapters in this book really make it a must-purchase for any Joomla developer. The Multilingual Recipes chapter gives more in-depth information on internationalization and character encodings than any other Joomla reference I’ve seen. Even if you’re only creating a website in one language, it’s imperative that you understand how character encodings work. Current versions of PHP have some shortcomings with handling UTF-8 strings, but Joomla’s special libraries will help you handle them correctly.
Character encodings aside, Keeping it Extensible and Modular is the most useful chapter in the entire book. This chapter is devoted to helping you work with Joomla’s different extension types and getting around some of the shortcomings in 1.5. For instance, James shows you how to create installable libraries by creating a custom type of plugin.
Also, this chapter has a recipe for using the component installation process to install additional extensions. This method allows you to include your modules and plugins inside of your component package; installing multiple extensions in one click. I plan on using it as soon as I get a chance to work on the Podcast Suite!
While the content in this book is very strong, it does have a couple of drawbacks. While most of the recipes have readily usable code that’s straightforward, a few of them don’t make a strong case for why you would use the described method. For instance, there’s a recipe on creating and raising a custom error level. It goes into how you want to avoid conflicting with Joomla and PHP error codes, but it doesn’t explain why you would want to create a custom error level in the first place. Fortunately, most of the recipes have more context.
I’m willing to read more than two pages… seriously.
The biggest disappointment of this book is in the execution of the cookbook format. Having read other “programming cookbooks” in the past, I know that the goal of these kinds of books is to help you find relevant information on specific topics quickly. However, Packt seems to have decided that providing “quick information” means catering to readers with severe cases of attention deficit disorder.
If you try to read entire chapters of this book at a time, you’ll notice that some recipes are almost identical. In Chapter 7, there are individual recipes on setting the HTML document generator, description, and metadata. These add up to less than three pages, but all include the same introduction at the beginning of each. Additionally, all three of these include “See also” references to each other. These would have worked much better as a combined recipe, including a reasonable scenario where you would want to set these things. In its current form, almost half of your reading consists of headers and duplicated information.
Hidden Joomla treasures
Despite the sometimes choppy format, the Joomla! 1.5 Development Cookbook organizes a lot of how-tos missing from Joomla’s online documentation. Anyone coding anything more than the simplest module can benefit from the recipes in this book. James demonstrates expert programming knowledge and delivers it in a very accessible format. The time you’ll save by having this information at hand will offset the cost of purchasing it within the first week. If you’re writing code for Joomla, you need this book.
UPDATE: you can also read a PDF sample of Chapter 2 from Packt’s website.
I’ve always been a skeptic of SEO “best practices.” A website that reminds me of this is titled “The Japan FAQ: know before you go.” Several years ago, I was marginally interested in what it would take to teach English in Japan. So I found this extensive website and read up. It’s one of those sites that someone started writing and just kept going at, with minimal navigation and loooooong pages. You get lost in the content, but you keep reading because it’s is full of anecdotes.
For some reason, I wanted to look up this page again, so I Googled “japan faq”. Lo and behold, it was the top hit. A peek at the source reveals this site follows almost none of the oft-quoted SEO practices necessary to get to the top. Some of the pages have two <h1> tags, some have none. The HTML doesn’t validate. There are multiple unclosed <body> tags. Some of the tags are capitalized, some pages don’t have any <meta> tags. There are <font> tags all over the place. It’s 1997-era tag soup at its finest.
This made me wonder about the quality of top-ranked pages for other search terms. So I began typing in terms at random:
- breast cancer
- beethoven’s 5th
- war of 1812
- michael jordan
- kung pao chicken
Yet they all rank very well in Google. This leads me to believe that SEO is nothing more than a tie-breaker in edge cases. It could be that your site is simply swimming amongst other edge case websites. However, sometimes it seems that for all of the effort people put into SEO, they would yield comparable results by getting people to talk about their website. Both interesting content and good old-fashioned interpersonal networking can help with that.
Valid markup can’t hurt though.
(* I’m excluding Wikipedia from the top pages as it’s the exception that proves my point: wikipedia.org’s overall pagerank is absurdly high because Wikipedia is ridiculously popular. The markup Wikipedia uses is largely irrelevant.)
Packt Publishing recently sent me a review copy of Joomla 1.5 Template Design by Tessa Blakeley Silver. Since I read most of it away from my computer, I wasn’t able to work through the examples. While I can’t speak to how well the code examples matched the actual process of building the template, I did enjoy reading the book. Coming in at 259 pages before the index, this book has enough content to cover everything you need to know while not wearing out its welcome.
The strongest part shines in Chapter 2, where Tessa introduces her “Rapid Design Comping” technique. This markup-centric approach helps you get your typography and HTML right first, then goes back and creates accompanying graphics. By getting your basic HTML and CSS out of the way up front, you don’t run into issues where you’ve designed a layout in PhotoShop that doesn’t translate to the web. Her coverage of this method is easily worth the price of the whole book.
Another plus is that Tessa incorporates HTML and CSS validation as a part of your template design workflow. Although having valid markup does not guarantee that your design will display properly in all browsers, it does help you avoid many such inconsistencies from the outset. She also covers common browser hacks (mostly to accommodate Internet Explorer 6) and how to use them as sparingly as possible. Finally, she also dives into avoiding quirks mode rendering and how to handle inconsistent renderings of the box model.
Coverage of Joomla-specific code and techniques is extensive, including custom module chrome and template parameters. She includes a complete reference for all <jdoc:include /> tags, as well as CSS selectors output by the Joomla core. Joomla template-specific PHP is also explained, but without going too deep into code that might confuse people without a programming background.
Despite a strong foundation in the fundamentals of Joomla templating and HTML/CSS, the book does have faults. There are some places where Tessa states something pensively (for instance, date formatting in XML manifests on page 138) which makes you wonder whether or not she’s confident about what she’s describing. Conversely, her description of the Model-View-Controller design pattern is very confidently stated, but slightly inaccurate. Fortunately, she describes the relevant details of View overrides correctly. That said, a more consistent voice would make the book easier to read.
Despite a few missteps, this book is a solid introduction to the ins and outs of building a template in Joomla. All of the standard syntax is covered, along with a practical overview of how to structure your HTML and CSS for optimal browser compatibility. Advanced topics are also tackled head on, making this book the most complete reference for building Joomla templates that I know of. If you need to build a template or are curious about the process, this book should definitely be on your shelf.