Solspace is pleased to announce the release of Tag 2.6, available today. We have been working hard on the module and have incorporated a new Subscription ability, so that your users can track new gallery and weblog entries based on Tags. Depending on your desires users can track their own subscriptions, subscriptions of other members, or all subscriptions side-wide. There are many other new features and bug fixes, please see the change log for complete information.

Tag 2.6 can be purchased and downloaded directly from the ExpressionEngine Store or through Solspace. This is a free update for existing Tag customers. Please download 2.6 where you purchased it from.

Many wonder what’s taking us so long with 2.0.  Hopefully this little walk through code conversion will help answer that question.  Rewriting all of ExpressionEngine to a new architecture is a time consuming process, there’s just no way around it.  It’s not glamorous work, and we have a very small team of developers who carry many duties in addition to programming ExpressionEngine 2.0.

We knew it would be arduous when we began, but we were and remain firmly convinced that the change in architecture is the best for ExpressionEngine’s future.  We’re setting a foundation for many many years of excellent development to come, from both first and third parties, that would have been difficult or impossible with ExpressionEngine 1.x.  We readily admit, though, that we underestimated the time it would take.

It simply hasn’t been possible for me or Derek Allard to break from that work at regular intervals to share new things.  When we’ve hit milestones with things that are legitimately new with 2.0, we’ve shared them with you.  We haven’t, however, bored you with the drudgery I’m about to share with you.  What follows is a very small code snippet from ExpressionEngine 1.6.6’s control panel, 30 or so lines of code including comments and white space.  I’ll walk through how that code is changed to become code that works with the new architecture we’re establishing with 2.0.  The code will do nothing new in the end, it will just do what it does in a different way.  Functionally, it’s a member group selection box in the Communicate page.

Here’s where we start:

/** -----------------------------
/**  Member group selection
/** -----------------------------*/
      
if ($DSP->allowed_group('can_email_member_groups'))
{         
    $r .= $DSP->table('tableBorder', '0', '', '300px').
          $DSP->tr().
          $DSP->td('tableHeading').
          $DSP->qdiv('itemWrapper', $LANG->line('recipient_group')).
          $DSP->td_c().
          $DSP->tr_c();

    $i = 0;
    
    $query = $DB->query("SELECT group_id, group_title FROM exp_member_groups
                         WHERE site_id = '".$DB->escape_str($PREFS->ini('site_id'))."'
                         AND include_in_mailinglists = 'y' ORDER BY group_title");
    
    foreach ($query->result as $row)
    {
        $style = ($i++ % 2) ? 'tableCellOne' : 'tableCellTwo';

        $r .= $DSP->tr().
              $DSP->td($style, '50%').$DSP->qdiv('defaultBold', $DSP->input_checkbox('group_'.$row['group_id'], $row['group_id'], (in_array($row['group_id'], $member_groups)) ? 1 : '').$DSP->nbs(1).$row['group_title']).$DSP->td_c()
             .$DSP->tr_c();
    }        

    $r .= $DSP->table_c();
}

In addition to syntax changes, for this to make the translation to ExpressionEngine 2.0 architecture, there are a few overarching goals, that will be familiar to many CodeIgniter users.

• Models provide access to data.
• Views control presentation.
• Controllers contain logic.

This is all in addition to switching to CI’s syntax, libraries, helpers, etc.  One of the challenges we most underestimated that faces us is separating these things, particularly the elimination of the old control panel Display class.  As you can see even in this simple code above, it’s interspersed throughout the logic, and indeed built as the logic is processed, which is the antithesis of programming with an MVC approach.  It is necessary to get the data from the model, prepare it as needed, and then pass it off, complete and ready to go, to a display method.

So, let’s look at the controller first.  It’s portion of the above code will become:

if ( ! $this->cp->allowed_group('can_email_member_groups'))
{
    $vars['member_groups'] = FALSE;
}
else
{
    $query = $this->member_model->get_member_groups();

    foreach ($query->result() as $row)
    {
        $checked = ($this->input->post('group_id'.$row->group_id) !== FALSE OR in_array($row->group_id, $member_groups));
        $vars['member_groups'][$row->group_title] = array('name' => 'group_'.$row->group_id, 'value' => $row->group_id, 'checked' => $checked);
    }            
}

ExpressionEngine 1.x’s global objects are gone, everything is handled through the super object.  You’ll notice how little, if any, of the original 30 lines would survive a cut and paste.  Even the foreach() is changed, since the database return object is different in 2.0.  But gone is anything at all related to the display of the item or building string output.  The controller gets the data from the member model, and then processes it into an array that will prove invaluable to our view file later.  Before we go there, though, let’s look to see what happened to the data query.  For that, we turn to the member model.

/*
* Get Member Groups
*
* Returns only the title and id by default, but additional fields can be passed
* and automatically added to the query either as a string, or as an array.  
* This allows the same function to be used for "lean" and for larger queries.
*
* @access    public
* @param    array
* @param    array     array of associative field => value arrays
* @return    mixed
*/
function get_member_groups($additional_fields = array(), $additional_where = array(), $limit = '', $offset = '')
{    
    if ( ! is_array($additional_fields))
    {
        $additional_fields = array($additional_fields);
    }
    
    if ( ! isset($additional_where[0]))
    {
        $additional_where = array($additional_where);
    }

    if (count($additional_fields) > 0)
    {
        $this->db->select(implode(',', $additional_fields));
    }

    $this->db->select("group_id, group_title");
    $this->db->from("member_groups");
    $this->db->where("site_id", $this->config->item('site_id'));

    if ($limit != '')
    {
        $this->db->limit($limit);            
    }

    if ($offset !='')
    {
        $this->db->offset($offset);            
    }
    
    foreach ($additional_where as $where)
    {
        foreach ($where as $field => $value)
        {
            if (is_array($value))
            {
                $this->db->where_in($field, $value);
            }
            else
            {
                $this->db->where($field, $value);                    
            }
        }
    }
    
    $this->db->order_by('group_id, group_title');
    
    return $this->db->get();
}

Why so complicated instead of the exact query that was used previously?  Abstraction.  This method can now be used by any controller needing access to information about member groups, simply by telling it how much information you want back.  You’ll also notice (if you’re a CodeIgniter user) that we’re using Active Record.

Ok, so this method fetches the data from the database, which the controller used to build that snazzy array.  Our view file knows what to do with it.  Here is where the display and output occurs, and here’s what handles this particular array, in the new Communicate view file:

<?php if (is_array($member_groups)):?>
<h3><?=lang('recipient_group')?></h3>
<ul class="shun">                        
    <?php foreach ($member_groups as $group => $details): ?>
    <li class="<?=alternator('even', 'odd')?>"><label><?=form_checkbox($details)?> &nbsp;<?=$group?></label></li>
    <?php endforeach; ?>
</ul>
<?php endif; ?>

The logic in the view file is simple: loops and basic conditionals only.  No data processing.  Helpers handle the nitty gritty, in this case the String Helper’s alternator() function replaces our old $switch logic, and the Form Helper’s form_checkbox() takes the array we built earlier, and generates the checkbox form element for us.

The end result is great.  Our controller logic is clean and easy to follow, our model allows us to build methods to fetch data in an abstract way so we don’t have to write similar queries over and over, and the view file makes it incredibly easy to modify the markup in the control panel if it is necessary.  But it is a slow, painstaking process to perform these conversions, all the while without introducing new bugs from the fresh code.

I warned you it wasn’t glamorous!  In fact, some software developers declare such rewrites to be nothing short of sin.  In some respects that’s rather true.  But the technology landscape has shifted dramatically since the design of ExpressionEngine 1.0, and to setup for great things in the future, ExpressionEngine 2.0 is the exception to the rule, deserving the rewrite and wholly new architecture.  Some of the pitfalls of such an undertaking still apply though.  The process is slow and tedious, code, even your own well commented code, is harder to read and decipher full intent than it is to just write new code, we cannot neglect the existing version, and our time is dictated more by what code doesn’t exist yet than on what we, as developers, would enjoy working on.

Hopefully this will answer some community member’s questions as to what we’re spending our time with, why it’s taking so long, as well as why we do not stop every couple of weeks to talk about what was accomplished.  The 1.x branch has not fallen by the wayside during this long process, and I suspect it will not fall away anytime soon.  ExpressionEngine 1.x is a solid product, and an excellent choice of CMS for a wide variety of projects, and will remain so for some time.  ExpressionEngine 2.0 isn’t a necessary addition to your arsenal today, but it will provide a foundation to keep ExpressionEngine in your arsenal five years from now.  And we can’t wait to share it with you when it’s ready.  Now, back to work!

ExpressionEngine version 1.6.6 has been released today, and contains a security update along with a few maintenance items and bug fixes.  A successful exploitation would only lead to an annoying display issue (your data is not compromised), so we even debated including the fix in a normal build update.  However, there’s a bleeding edge scenario with many puzzle pieces (including the use of some third party software) where it could be quite serious.  So, for your safety, we decided to go with a point release, recommending this update for all users in a timely manner.

Our support staff is on hand and ready to assist you with any issues you may encounter while updating.  As always, if you do not skip any steps in our simple step by step update instructions, it should be a breeze and take just a few moments of your time.

We have a new opening for a Technical Support Specialist. This position is the front line of ExpressionEngine support. You’ll be working with our excellent support team in a collaborative environment from the comfort of your own home (or coffee shop or your favorite place with internet access). This is a Part-time position that we “hire up” from. Our CTO, Director of Community Services, Technology Architect, and Code Mechanic all started on the support team.

You can find the details on the EllisLab Jobs page but here are some tips on getting the job (we had a lot of applications last time):

- You are a self-starter, able to learn and act independently, yet capable of interacting with a team on a regular basis.
- You have experience with ExpressionEngine. There is no way around this. It helps if you’ve built at least several sites in ExpressionEngine, the more the better.
- 100% of the job is written communication. You must be responsive and able to communicate well in the English language.
- Patience and good humor are practically requirements when engaging in support.

Good luck!

Since the Developer Preview is still a ways off, I thought I would share something code-wise that is completely new to 2.0, control panel Accessories.  This is a very very basic accessory, that just displays some simple static information in the tab for the user.  We anticipate that these sort of accessories will be common for design firms to use, as each has a particular way that they like to instruct their clients on how to use the control panel, publish information, find out important details with respect to their account, etc.

The information in this post is targeting developers; users will never be exposed to any of this, in the same way that they don’t have to learn how plugins and extensions work to be able to use them.  Let’s break it down:

class Sample {

    var $name           = 'Sample';
    var $id             = 'sample';
    var $version        = '1.0';
    var $description    = 'A static Accessory demonstrating the basics of how Accessories work';
    var $sections       = array();

Like all other add-ons, you will have your primary class, whose name will match the file name just like plugins, modules, and accessories do now.  In this case, the file would be acc.sample.php.  There are some required class properties that control how your Accessory is displayed in the control panel.  The $name is the name displayed both in the list of available Accessories, and in the Accessory’s tab itself.  The $id is the id= attribute that is applied to your Accessory’s container, allowing you to target your content with CSS and JavaScript if necessary.  $version and $description are self explanatory.  $sections is an array that is accessed by ExpressionEngine to build your Accessory’s content.  To add content to your Accessory, you simply add it to the $sections array.  So simple that even those with zero PHP experience can do it.

/**
* Constructor
*/
function Sample()
{
    // load the EE super object
    $this->EE =& get_instance();
}

Next we have the class constructor.  Basic PHP stuff here, with the addition of something that will be familiar to CodeIgniter users, a local reference to the application super object.  More on that later.

/**
* Set Sections
*
* Set content for the accessory
*
* @access    public
* @return    void
*/
function set_sections()
{
    $this->sections['Heading One'] = '<p>Lorem ipsum dolor sit amet, consectetur adipisicing elit,
                                    sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
                                    Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris
                                    nisi ut aliquip ex ea commodo consequat.</p>
                                    
                                    <p>Duis aute irure dolor in reprehenderit in voluptate velit esse
                                    cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat
                                    cupidatat non proident, sunt in culpa qui officia deserunt mollit
                                    anim id est laborum.</p>';
    $this->sections['Heading Two'] = '<ul>
                                        <li>List Item One</li>
                                        <li>Another List Item</li>
                                        <li>And something else</li>
                                      </ul>
                                      <p>(c) Copyright 2008 Me. All Rights Reserved.</p>';
}

This is the one required method in your Accessory class.  It is automatically called when the Accessory is loaded, and is what you will use to set (whoda thunk?) your content into the $sections array.  The array keys are output as headings, and can be named anything you like.  They are output in the order they are added to the array.  The value of each array key is the full content, including any markup you wish to use, of that “section” of your Accessory.  As you can see above, for an Accessory that wishes to display static information, it’s dead simple.

But what about more complex Accessories?  You essentially have no limitations apart from what you can do with PHP and MySQL.  You can have install() and uninstall() methods, which are automatically triggered on those actions, so you can use your own data tables.  They can have their own language files, and you have full access to all of the libraries and resources of ExpressionEngine, via the $this->EE super object.  Database library (including Active Record), Security library, Typography library, Email library, jQuery, and so on.

So what’s it look like?  What is the result of this simple accessory demo? (click for full size image)

And for your viewing pleasure, the entire, unbroken file.

<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
/**
* ExpressionEngine - by EllisLab
*
* @package     ExpressionEngine
* @author      ExpressionEngine Dev Team
* @copyright   Copyright (c) 2003 - 2008, EllisLab, Inc.
* @license     http://expressionengine.com/docs/license.html
* @link        http://expressionengine.com
* @since       Version 2.0
* @filesource
*/

// ------------------------------------------------------------------------

/**
* ExpressionEngine Sample Accessory
*
* A static Accessory demonstrating the basics of how Accessories work
*
* @package     ExpressionEngine
* @subpackage  Control Panel
* @category    Accessories
* @author      ExpressionEngine Dev Team
* @link        http://expressionengine.com
*/
class Sample {

    var $name           = 'Sample';
    var $id             = 'sample';
    var $version        = '1.0';
    var $description    = 'A static Accessory demonstrating the basics of how Accessories work';
    var $sections       = array();

    /**
     * Constructor
     */
    function Sample()
    {
        // load the EE super object
        $this->EE =& get_instance();
    }

    // --------------------------------------------------------------------

    /**
     * Set Sections
     *
     * Set content for the accessory
     *
     * @access    public
     * @return    void
     */
    function set_sections()
    {
        $this->sections['Heading One'] = '<p>Lorem ipsum dolor sit amet, consectetur adipisicing elit,
                                        sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
                                        Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris
                                        nisi ut aliquip ex ea commodo consequat.</p>
                                        
                                        <p>Duis aute irure dolor in reprehenderit in voluptate velit esse
                                        cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat
                                        cupidatat non proident, sunt in culpa qui officia deserunt mollit
                                        anim id est laborum.</p>';
        $this->sections['Heading Two'] = '<ul>
                                            <li>List Item One</li>
                                            <li>Another List Item</li>
                                            <li>And something else</li>
                                          </ul>
                                          <p>(c) Copyright 2008 Me. All Rights Reserved.</p>';
    }
    
    // --------------------------------------------------------------------
    
}
// END CLASS

/* End of file acc.sample.php */
/* Location: ./system/expressionengine/accessories/acc.sample.php */

We are extremely happy to announce that our long time in-the-trenches member of the support staff, Robin Sowell, has stepped up to become the new Code Mechanic for EllisLab.  Many of you have known her for over three years as she has provided top rate support, often going well above and beyond the call of duty, always eager to do what it takes.  In addition to daily helping users with their support needs, she has written add-ons, built a number of ExpressionEngine sites, and has become recently engrossed in CodeIgniter.

Robin has been a valuable asset to EllisLab and we’re happy to be able to provide a full-time roll for her as a member of the development team.  I do have to apologize to many of our users for removing her from the daily technical support tasks, but you’ll still see her around, handling issues that need a keen eye, and hanging out in the development forums.  With over 20,000 posts, she’s been a very visible part of the ExpressionEngine experience to most everyone, and we’re happy that that will continue in an increased capacity.

With such new features as tighter control over your URLs, better Auto-XHTML typography, advanced control parameters for the weblog entries tag, and an included extension to enable jQuery in your control panel for third party add-ons that utilize it, 1.6.5 brings a lot of goodness to the table.

To read about the 60-some changes to ExpressionEngine 1.6.5, please see the Change Log in the user guide.  Head on over to your download area and grab the update!

We’ve added over a 100 new sites to the Showcase Gallery. We also took the opportunity to tweak the Showcase navigation to make exploring easier.

When Showcase Gallery is clicked in the sidebar a menu with viewing options opens. You can now view the Gallery by Newest, Oldest, Alphabetically, “Random 9”, and a Quick List view that displays text links to all the sites. Of course you can still view them by Category as well.

More importantly the Showcase Gallery & Interview submission process has been overhauled and streamlined. This work is mostly behind the scenes but what it means is that Showcase Gallery Requests should be added within 2 business days of submission, if not sooner. We are committed to staying current with the Showcase Gallery.

Interviews, however, are still going to be difficult to secure. The submissions page has tips on how you can make your interview request stand out but the reality is that the demand is high. We try to mix the interviews up between high profile projects, up & coming developers, unique implementations, non-profits, off-the-wall sites, and the good old-fashion blog. We want to give anyone with a compelling story a chance.

Note: Strict URLs changed between this posting and the release of 1.6.5. Please see the Strict URLs section of the User Guide for details.

Originally planned as a feature for 2.0, Strict URLs will be sneaking into EE 1.6.5 (due soon). So this time around you get a preview of a 2.0 feature that you won’t have to wait for 2.0 to start using.

ExpressionEngine already has a number of ways to handle 404 pages but one of the most requested features from Search Engine Optimization (SEO) specialists has been the ability to “lock down” EE’s URL structure to enforce a more traditional use of 404 pages and help avoid inadvertent “Duplicate Content Penalties” from Search Engines. If you’re interested in learning more about what exactly that is, SEOmoz has a Illustrated Guide.

For example, say your Default Template Group is called “site” and you have a template called “news” in the same Template Group. Currently, EE will render the same content from both these URLs, assuming that you do not have a “news” Template Group:

http://example.com/index.php/site/news/
http://example.com/index.php/news/

This happens because if the first URL segment that EE encounters is not a valid Template Group, it will look for a Template of the same name in the default Template Group instead. If a person has coded both links in the site, the result can be that a search engine will think there is a duplicate content situation.

Another scenario where Strict URLs is useful is delivering 404s when the URL is manipulated by the user. For example, say someone attempts to go to the news portion of a site, but misspells part of the URL.

http://example.com/index.php/news/sprts/

There is no Template called “sprts”. Currently EE will ignore the misspelling and display this instead:

http://example.com/index.php/news/index/

When Strict URLs are enabled EE will display the specified 404 page and send 404 headers in both these situations.

http://example.com/index.php/404/

Here are the exact rules governing Strict URLs.

If no segments are found in the URL, your default template will be shown.

If the first segment exists and does not correlate to a valid Template Group, ExpressionEngine will display a 404 page and send 404 status headers.

If the second segment exists and does not correlate to a valid Template, ExpressionEngine will display a 404 page and send 404 status headers.

Our official recommendation will be that people enable Strict URLs but for legacy reasons it will be disabled by default. Please note that if you decide to use Strict URLs all the “path” variables in your templates must specify the template group and the template, like this:

{path='weblog/index'}

This is what we’ve always recommended. It also means that you will no longer be able to “short cut” around the default site Template Group.

Solspace helped IDEO launch their new website on ExpressionEngine.

Solspace, using ExpressionEngine as IDEO’s chosen web development platform, wrote new software, developed new applications, and worked closely with the IDEO team to create a dynamic and engaging new web presence.

Newism (who just recently joined the Pro Net) released LG LiveLook “an ExpressionEngine extension that adds a new ‘Live Look’ tab to the publish/edit form in the control panel.” The site has a tutorial on how to set it up, it comes with documentation, and they have a thread going in the EE forums where you can get additional support.

Train-ee launched a gorgeous redesign with the help of Derik from Shift Design. Check it out!

bkuberek contributed an EE Wiki article on using MAMP for EE development. “For those who like run MAMP as close to a live server as possible, here are a few tricks.”

Hop Studios released Defensio for ExpressionEngine, an add-on that works with the anti-spam system Defensio (free for Personal use). 

And last, but not least, don’t forget Ryan Irelan’s ongoing live ExpressionEngine Help Chat sessions on EE Screencasts. They take place Wednesday evenings at 9pm ET, are completely free, and he’s been giving 20% off coupons for the EE Screencasts to people who attend the Chats.

Have something that you want featured on the EE Blog? Just .

Travis (Hop Studios) posted an EE Roadshow wrap up (don’t miss the pictures).  Derek Allard also posted about his Roadshow experience.

Ryan (Masuga Design) is launching a new site dedicated to EE. Sign up for advance notice at Devot-ee.com.

Nathan Pitman is blogging about his experience migrating to ExpressionEngine.

GDMac released a Minimalist Member Profile theme on the EE Wiki.

This past spring Viget Labs wrote a series of articles about Building Viget.com in ExpressionEngine.

Onwired’s Patrick blogged about their ExpressionEngine Recipe Book.

Stephen introduced an extension that automatically adds newly registered members to MailBuild or CampaignMonitor.

nGen Works released Structure which they are billing as “a new way to build ExpressionEngine sites.” We’ve not personally used it yet.

Leevi, who has established himself as a veteran EE developer, released LG Twitter 2, a free add-on that… well, you can probably guess what it does.

And last, but not least, Web Inception is running a Building a Site with ExpressionEngine series on their blog.

Have something that should be mentioned on the blog? .

Hi Folks,

This is just a brief update to let everyone know that progress on 2.0 is going smoothly. We promised regular updates, but we aren’t going to include previews and/or new information with every update. For the curious, the dev team is currently working on module conversion and testing.

However, there is hope for new info in the near future. Rick Ellis and Derek Allard are at the EE Roadshow today and rumor has it that Allard might be demoing a little 2.0 for the attendees. If Rick and Allard talk about new 2.0 info at the Roadshow we will be sure and share it here on the blog for you next week as well. Have a great weekend!

Congratulations to Capt.Mike and DavidB. You each get a copy of Building Websites with ExpressionEngine 1.6. I’ll email both of you shortly to work out the details.

Also thank you to Packtpub for providing the books and to Leonard for writing it!

Packt Publishing sent us several copies of Leonard’s Murphy’s Building Websites with ExpressionEngine 1.6. Though it is not the first EE book, it is the first dedicated EE book from an established technology publisher!

Let’s get to the important part first. We’re giving away 2 copies of Building Websites with ExpressionEngine 1.6. To enter all you have to do is post to the Discussion thread linked at the top of this post before Tuesday (September 23), 3pm Central. To win you have to be somewhere that a major shipping service in the US will ship to (UPS, FedEX, USPS). That should be most of you. Oh, Mark Bowen is ineligible to win since he is the book’s Technical Reviewer and already has a copy. Good luck!

If we weren’t super-busy with that thing we’re working on, we’d give it an expanded review. I’m also sick (its 24 hour fever season in Lincoln NE).

But here is the condensed version. The book is aimed at beginners but has enough extras to keep those with a couple of EE sites interested as well. If you’re already an EE guru, its a good collector’s item for your bookshelf that you can lend to interested friends or an opportunity to see how someone else approaches EE (everyone has their own flavor). While we could nitpick this and that, the bottom line is that its a solid book that delivers on its title’s promise. Leonard has the sample code and website available for download.

Note that Leonard is not a graphic designer (and doesn’t claim to be). That is clear in the book’s examples. If you are brand new to EE, check out the Showcase to see just what can be done with EE.

If you want expanded reviews, Jensa posted one on Flashgamer and simsa reviewed it for TXP Magazine.

Ryan Irelan, the man behind EE Screencasts, is offering to provide EE answers in real time.

Bring your EE questions, problems and issues and I’ll do my best to help you out. I enjoy helping other people solve their EE problems and now I want to try doing it in a weekly one-hour chat. The chat will take place at 9 PM on Wednesday.

The chat goes for 1 hour and is limited to 12 people at a time. Ryan has some guidelines about the questions starting with “No question is too simple. If you’re new to EE, don’t be afraid to ask your question.” He’s setup a EE Help Chat page with all the information you need to participate.

Good luck Ryan! Don’t forget, dynamic=“off”.

I got a note from Kevin today letting me know that there are only 13 tickets left for the EE Roadshow, which takes place September 26 up in Vancouver. Tickets are only $50. Our fearless leader Rick Ellis will be there along with a bunch of people from the EE Community. It will be a good time (wish I could make it). Rumor also has it that EllisLab will be giving the EE Roadshow folks some door prizes.

Plus, if you can extend your stay you can attend Barcamp Vancouver which opens the following day.

Mike Boyink posted a wrap up on the EE Session over on the Train-ee blog.

By the end of the week it felt more like summer camp - where you make fast friends and hate to say goodbye at the end.  People were hugging each other, trading business cards, connecting via Facebook/Twitter, and conversations already included talk of a reunion.

There is also a photo set up on Flickr. I’ve pulled out a few of my favorites.

The mandatory group photo! Check out the EE Mugs

AJP agreed to help Mike out.

Reports say there was very good food.

The promised cookout happened.

Eventually some EE training took place!

Again, a big thanks to the Sponsors who made the two scholarships possible.

Design by Reese
EECoder
EngineHosting
ExpressionEngine Screencasts
EE Templates
ejaeDesign
emtwo
Gear Live
Hambo Design
Userscape, makers of HelpSpot
Insight Studios
Masuga Design
paramore | redd
Shape Shed
Yellow Seed

There are some great things happening out in EE Land (the EE Community Forums and beyond in the wild vastness of the Intertubes*).

First I want to direct your attention to EE and You from George at Shape Shed. George’s dry-British humor gives a different take on EE video tutorials which I quite enjoy. EE and You is advertisement driven which means they are free to watch.

Airbag’s EE Guru Ryan Irelan bring you First Timer, an Extension that will “Redirect members to a special landing page the first time they log in to an ExpressionEngine site.” This is the same Ryan behind EE Screencasts.

John from Tyssen Design has written up a tutorial on extending the PayPal options in SimpleCommerce with the help of Related Entries and an extension from Mark “I write lots of useful EE stuff” Huot. John recently added this article to the EE Wiki as well.

WTHIGO? has started a collection of Clips for Panic’s Coda and made them available on the EE Forums. If you are a Coda user, consider contributing to his efforts there.

Marcus Neato runs an “ExpressionEngine Theme Studio” called EE Templates. If you are a forum regular you probably already knew that. What you may not know is that Marcus is giving away the two and three column versions of his Shades of Grey Theme for free. You can find both in the Freebies category of the EE Templates Blog.

Do you have a resource you want me to list on the EE Blog? I’d love to know about it. Just leslie.camacho@ellislab.com and tell me a bit about it. It could be a forum post that helped you out, an article, an Add-on, anything EE related will do and self-promotion is just fine. I’ll collect the best of them and post them on the Blog. With any luck, this will turn into a regular feature.

* Fun note. Senator Ted Stevens, the very one who made the comment about the internet being a series of tubes, his re-election website is on EE. I’m not making a political statement or endorsement of any kind here, I just find it amusing that the series of tubes just may be EE powered.

On the off chance you can make it to the West Michigan area tomorrow evening, Mike Boyink is offering free beer & pizza to kick off the first Train-ee ExpressionEngine Session. You can find the details on the forums. You do not have to be part of the Train-ee Session to attend, just show up and hang out with the W. Michigan EE crowd. Apparently the Chicken Alfredo pizza is worth the trip.

All summer we’ve been focused on our goal of first getting the developer preview of EE 2.0 released, then the public version.  The good news is that the majority of our work is done.  We’ve had a very productive summer and accomplished a lot.  Most of the major systems have been completed, and the CodeIgniter integration is functioning very well. 

Unfortunately, there still remain enough loose ends and details to make a summer release impossible.  We’re close, but as the saying goes, the devil is in the details, so we need to push the release into fall.

I apologize to all who have been anxiously awaiting 2.0, but I can assure you that we are as anxious to get 2.0 released as you are to get it.  This has been a huge project for us, so we need to get it right.  Rushing it to market before it’s ready would be irresponsible, so we ask that you give us a bit more time.  We promise the wait will be worth it.

Just for fun, here is a screen-shot of one of the alternate themes 2.0 will ship with.  Later this month (and on a regular basis until the release) we will share additional details and information that we think you’ll enjoy hearing.