Click Replay for hike animation

Wrapped up the visit with a lovely 3-mile walk through Carver Park Reserve with the family and kids through rolling hills. Returned with a few tics and lots of great memories.

Farewell Ben – we’ll always miss you.

As with Elvis, I dismissed most of what he did long before he left. But MJ was an arresting presence even for those who, like me, did my best to ignore him. Elvis even seems an inadequate comparison for his stratospheric global reach. A closer comparison might be Howard Hughes, another man-child of erratic brilliance, whose master aviator’s soaring heights later gave way to reclusive paranoia and heartbreaking tailspin.

Then, in The Aviator, Part II: Sky Saxon Moore pays tribute to Sky Saxon of The Seeds, whose death was completely overshadowed by Jackson’s.

The Seeds discovered trippy keyboards before the Doors, and were unleashing raw power before the Stooges. They were their best at their simplest, exemplifying Woody Guthrie’s dictum that if you use more than two chords, you’re showing off.

See also: Mayra Andrade’s Lunar Mission

AUTH_PROFILE_MODULE = 'accounts.UserProfile'

To make it easier to let users create and edit their own Profile data, James Bennett (aka ubernostrum), who is the author of Practical Django Projects and the excellent b-list blog, created the reusable app django-profiles. It’s a companion to django-registration, which provides pluggable functionality to let users register and validate their own accounts on Django-based sites.

Both apps are excellent, and come with very careful documentation. But here’s the rub: Bennett’s documentation style comes from the mind of an engineer, rather than an average user who just needs to get things done quickly. For people who write Django code every day and are intimately familiar with the official Django docs, they’re probably sufficient. For those of us who don’t have the luxury of being full-time programmers, who don’t live and breathe Django, they’re frustrating. Sample templates are not included, and no clues are given as to what should go in the templates you create. Likewise, the ability to customize the default behavior of the apps is only hinted at, not spelled out. Users coming from a CMS world where you install and configure a plugin and get instant functionality for your site quickly become frustrated.

From IRC logs, it appears that Bennett believes banging your head against a wall is a great way to learn. To an extent, that’s true. I know there’s no better way to learn a new tool than having to solve real-world problems with it. But at the same time, learning doesn’t only take place in the Django docs – it happens on mailing lists, in code samples on djangosnippets.org (which, by the way, is another of Bennett’s projects), and, yes, in documentation for add-on apps like django-profiles.

Let’s take an example: A developer wants to let users edit their own profiles. They get their Profile model registered, install django-profiles, and create a template at profiles/edit_profile.html. What goes in that template? Not much is needed, but the django-profiles docs don’t give you a clue (nor do they give you a clue where to find the answer in the Django docs). You’ll need something like this:

{% extends "base.html" %}
{% block title %}Edit Profile{% endblock %}
{% block content %}
<h1>Edit contact info for {{ user }} </h1>
<form method="POST" action="">
{{ form }}
<input type="submit" name="submit" value="Update" id="submit">
</form>
{% endblock content %}

Now access /profiles/edit/ and you’ll see all fields on your profile model represented with appropriate field types. So far so good. Now you probably want to customize two things, right off the bat. You may have fields on the profile that only administrators should be able to edit, and you want to hide those fields. And you may want to modify the success_url, to control where the user is sent after a successful form submission. The docs for django-profiles say that the provided edit_profile view takes optional form_class and success_url arguments. But how can you pass in arguments? You’re simply linking to the predefined URL /profiles/edit/ – there is no code of your own from which you can pass in arguments.

This is where things became inscrutable to me. I was at an impasse, with no clue or hint as to what to do next. If the django-profiles docs had included a link to the section of the Django docs that contained the answer (or some kind of directional indicator) I could have done the research and gotten things moving. Fortunately, a friend and fellow Django developer had been down this road before and had the solution. Here’s how the pieces connect:

First, you need to create a custom ModelForm based on your Profile model. If you don’t already have a forms.py in your app, create one, then add something like:

from django.db import models
from django.forms import ModelForm
from ourcrestmont.itaco.models import *

class ProfileForm(ModelForm):
  class Meta:
      model = Foo
      exclude = ('field1','field2','field3',)

The idea is to pass your custom ModelForm to django-profiles with the name form_class, thereby overriding the default object of the same name. django-profiles will then operate against your custom ProfileForm rather than from a default representation of your Profile model. Once I understood this, the light went on and things started to snap into place.

Still, how can you pass this custom form_class to django-profiles, when there’s no view code in your own app to handle this? That’s where trick #2 comes in: The seldom-used ability to pass dictionaries of custom values in from your urlconf. So wiring things up now becomes a pretty straightforward task. In urls.py, import your custom form and pass it through to the django-profiles view, right after the reference to the django-profiles urlconf (you want to do this after, not before, so the last matching URL for /profiles/edit/ is the one you define, not the one django-profiles defines:

from projname.appname.forms import ProfileForm
    ('^profiles/edit', 'profiles.views.edit_profile', {'form_class': ProfileForm,}),
    (r'^profiles/', include('profiles.urls')),

You can pass in your custom success_url value in the same way:

from projname.appname.forms import ProfileForm
    ('^profiles/edit', 'profiles.views.edit_profile', {'form_class': ProfileForm,'success_url':'/my/custom/url',}),
    (r'^profiles/', include('profiles.urls')),

Now access /profiles/edit/ again and you’ll find that the view is using your custom form definition, rather a default one derived from the profile model. Pretty easy once you see how the pieces fit together. Unfortunately, I was not able to find these answers from the Django docs on my own – a friend supplied the answers.

If you need even more control than that, there’s another alternative to passing a dict in through the urlconf – write your own view with the name edit_profile, overriding aspects of the provided view of the same name:

from profiles import views as profile_views
from myprofiles.forms import ProfileForm

def edit_profile(request):
  return profile_views.edit_profile(request, form_class=ProfileForm)

(I haven’t tried this method).

profile_detail and profile_list

django-profiles enables other templates as well. As documented, the “details” template lets you retrieve all data associated with a single profile by sending an object named “profile” to the template profile/profile_detail.html, e.g.:

<p><strong>Address 2:</strong><br>
{{ profile.address2 }}
</p>
<p><strong>City:</strong><br>
{{ profile.city }}
</p>

It’s not quite so clear how to get a list of all profiles in the system. The docs say:

profiles/profile_list.html will display a list of user profiles, using the list_detail.object_list generic view

You’ll access the list view at /profiles/, with template code along the lines of:

{% for p in object_list %}
<a href=”{% url profiles_profile_detail p.user %}”>{{ p }}</a>
{% endfor %}

(in other words you can ignore the “list_detail.” portion of the object name referenced in the docs).
——————-

I have one remaining question: A common task when editing profile data would be to change one’s email address. But since the email address is included in the User model and not in the Profile model, it doesn’t show up in the {{form}} object. Anyone know how to get it in there?

With a few well-placed links and code samples, the django-profiles docs could be a great learning opportunity for this kind of Lego-like site construction. Until then, I’ll update this post with any other tips users provide on django-profiles implementation.

Despite my gripes about the docs, many thanks to Bennett for all of his excellent free code, writing, and other contributions to the Django community. And a ton of thanks to mandric for the golden ticket on how to wire up the pieces.

That’s why I’ve always been amazed to see how many developers and gear-heads use GMail. These are tech-savvy people, who I’d think would have the same frustrations with webmail that I do. What are they seeing that I’m not seeing? I totally get the convenience factor of being able to access my mail through any web browser, anywhere. I wouldn’t mind having that, but so far it hasn’t seemed worth the sacrifices. I know GMail keeps getting better, so thought it was finally time to give myself over to GMail for a week and see how it goes. Here are some notes on that experience.

n.b.: I’m using Google’s official list of keyboard shortcuts. I used the 3rd party tool A to G to convert Apple’s Address Book to CSV, then imported 1200 contacts into GMail’s contact system.

My list of GMail gripes, with a few faint praises in the mix:

- No way to change the default reading font. Really??? The default reading/writing font is just too small to be comfortable (for me), and it’s ridiculous that something this straightforward and ubiquitous in desktop clients would not be there. How hard can it be to give the user a choice of common font faces and sizes? Does not compute.

- No way to quote previous text before replying. Every desktop mail client I’ve used lets you select a block of text in a message, then hit Reply. Only the selected text appears in the reply. This is so core to netiquette and to my every day workflow that it seems like a non-negotiable feature. And yet no webmail client I’ve tried supports it. Not even GMail. No wonder over-quoting is such a problem these days. Later… OK, I discovered that this “feature” is actually available under Settings | Labs. When I enabled it, it complained that it could “not be loaded,” and continues to complain every time I exit the Settings menu, though it did work correctly in my first test. Cool, but why is it in Labs, as if it’s some kind of optional convenience that only a few people might want? How can this not be part of the default package? Core functionality.

- Inline photos. A family member sent 10 photos as attachments. When viewed in Mail.app they’re displayed inline, nice and large; GMail only shows thumbnails inline, though you can click “View all images” to see them full size on a separate page. There is of course no option to “Save all to iPhoto” in GMail. Since they were family photos, that’s exactly what I wanted to do.

- No preview pane. For realsies? I know of at least two webmail clients (RoundCube, which is available on Birdhouse, and Apple’s mac.com (errr, me.com)). If they can do it, why can’t one of the most popular webmail clients of them all?

- More clicks to view the next message. When done viewing one message, if you click Delete or Archive, you’re taken back to the full message list, which lacks a preview pane. So you then need to click again to view the next message. This kind of “more clicks/keystrokes to accomplish common tasks” is all over the place in GMail.

- No way to turn external mail checking on/off. I now have GMail configured to work as a POP client to two external accounts (would have configured it as IMAP, but GMail doesn’t support that, even though you can use external clients to talk IMAP to GMail – weird). Now I’d like to have GMail stop checking those two external accounts for a while, without removing all the config info. Too bad – the only way to make it stop is apparently to delete the account completely. Grrr…

- Poor conversation threading. GMail does an OK job at this – better than other webmail clients, but nowhere near as clean visually or as easy to navigate as threaded discussions in desktop mail apps. And because GMail shows a thread all on one page (thanks again to no preview pane), deleting individual messages out of the thread takes a lot more scrolling and clicking than it does in a desktop client. GMail’s threading is a pale imitation of technology we’ve had on the desktop for years. However, I really do like being able to see my own replies automatically in the context of the thread, even without having explicitly cc:’d myself, and without having to dig through the Sent folder. But the ease of expanding and collapsing a thread, of jumping to the next unread message in a thread, of deleting individual messages from a thread… all vastly superior in Mail.app.

In Mail.app, a thread is indicated by the presence of an arrow in the left column.

Cmd-RightArrow expands the thread; spacebar jumps you to the next unread message in the thread. The actual conversation is shown in the Preview pane. It’s easy to delete individual messages from the thread.

- Keyboard shortcuts. Yes, there are some. Yes, they work for the most part. But they’re not as ubiquitous or as clean to use as the keyboard shortcuts in a desktop client. I found myself doing a lot more mousing in GMail than I’m accustomed to doing in email.

- Adding contacts. I get a message from someone who’s not in my Contacts list. If there’s a way to add this person to my Contacts list on the fly, I’m not seeing it (yes, I looked). Mail.app makes this common process trivial and intuitive.

- Moving messages between accounts. One of the ways I rely heavily on IMAP is the ability to drag and drop messages between various mailboxes and servers. If I receive a message at work that I want to handle at home, I drag it from calmail to birdhouse, and vice versa. If I want to pull something out of cold storage (e.g. from a local mail store and put it back on a live mail server for handling), I can do that. GMail can be configured to talk to multiple accounts, but since it itself does not work like an IMAP client to foreign mail servers, it can’t do any kind of inter-server message moving. I guess the idea is that its model makes this kind of thing irrelevant, but it feels like a big missing piece of the modern mail experience.

- Integrated chat. Both GMail and Mail.app have this, but GMail clearly wins here when you’re at someone else’s computer since you don’t have to set up both the mail and chat clients (thanks @jrue for this point).

- “Send Again” feature. Not something you use a lot, but when you do, it’s a real time saver. Use this after sending a message to someone who’s address has died and you want to try again to the right address, or when you left someone off the original cc: list. Mail.app and other desktop clients have it. GMail doesn’t.

- Breaks quoting. Let’s say you’ve got a paragraph of quoted text in an incoming message and you want to reply to it in two parts. In a desktop client, you put the cursor where you want to break the graf and hit Return. A new quote mark is automatically added to the beginning of the new line. Not in GMail – you end up with the first line that should be quoted suddenly unquoted. Later… turns out this does work properly in rich text mode in GMail, but not in plain text mode. But I prefer to stay in plain text mode, only switching to rich text mode when necessary.

While replying in plain text mode in GMail, insert cursor in the middle of a paragraph and hit Return to start your reply. The new line lacks a starting mail quote mark, breaking netiquette and readability for the recipient.

- No Data Detectors. OK, this is only available in Mail.app, not all desktop mail clients, but it really is a killer feature. Roll over any date or time in any format, or any person’s name or email address, even in a plain text message, and you get a little drop-down menu that lets you quickly add that item to your calendar or address book.

Data detectors do an amazing job of figuring out all the right fields — almost magic (try it with messages referencing “tomorrow” or “next Tuesday.”) GMail does have an “Add Event” option but it’s nowhere near as intelligent or as slick, and it works for the whole message, not for individual text snippets within the message. Big win for Mail.app.

- Partial word searches. The search feature in GMail is nice, but is not better than the one in Mail.app. Yes, Google is a bit faster at returning results, but not by much (yes, Apple’s Spotlight is *that* fast). But here’s the kicker – Google and GMail can’t do partial-word searches. So if I’m looking for an email that I know includes the word “question” but I just type “quest” [Return] into GMail search, it turns up nothing! Wildcard searches don’t work either. Very frustrating. Even on their native search turf, Google loses to Apple. Update: There are also types of searches Mail.app can’t do, such as combined OR statements. So let’s call this one a draw.

- End-of-line key combo. On the Mac, the standard keyboard shortcuts to jump the cursor to the start/end of the current line are Cmd-RightArrow and Cmd-LeftArrow. These don’t work in GMail. In fact, as far as I can tell there’s no keyboard short to do this on the Mac in GMail. Which amounts to one more reason GMail is a lot more mouse dependent than using Mail.app or other desktop client. Can’t blame this on rich text editors either — WordPress uses a TinyMCE variant, and Cmd-RightArrow works there just fine. GMail is just broken in this respect.

- Ads in my email. They just bug me. I totally understand that that’s how I pay for the service. I get that. I still don’t like looking at them. Irritating. In fact, I found the whole GMail experience more cluttered and just… less elegant than working with a desktop client.

ADDED LATER

- Multiple windows. Sometimes I like to have two or more messages open at once, plus a compose window, so I can copy/paste bits around and between messages, or for reference while writing something new. Easy to do in a desktop client. Assumed I could do similar in GMail by cmd-clicking messages to open them in various tabs, but nope – GMail doesn’t allow that – forces you to only be looking at one thing at a time. Is that a feature they haven’t implemented yet, or an intentional limitation? Feels like the latter.

Upshot: I didn’t follow through on my promise to try GMail for a week. The frustration was too much to deal with, and I quit after four days. I’m back on Mail.app now. I probably missed out on some of GMail’s goodness, but overall, I left feeling exactly like I did going in. GMail has its advantages, but to me, it seems like they’re vastly outweighed by the absence of basic functionality and elegance present in all desktop mail clients (and by additional features in Mail.app) that I just missed too much. Feels good to be home.

We’ve attended all four years of Maker Faire now, so Miles has been there at ages 3, 4, 5 and 6 (does that qualify as a tradition?) I still think it’s one of the Bay Area’s most amazing explosions of talent and creativity — there’s nothing else like it. But this year there were noticeably fewer amazing giant steel sculptures, a much smaller presence from the incredible Cyclecide, more guard rails and safety precautions, more people (again), and more attendance from professional organizations. Year by year, the fair is starting to feel a bit less like a family-friendly version of Burning Man, a bit more like an opportunity for professional Lego collectors to network.

I don’t want to make too much of that though – Maker Faire most definitely has NOT started to suck. It’s still dazzling, inspiring, amazing. Just that it’s started to feel a bit… safer than it once did.

That said, Miles and I had an amazing day watching the Giant Mouse Trap, building inventions with computer scrap parts, learning about the SCA, “driving” the amazing snail car, watching the human llama wobble around, riding the wooden bikes (my fave part of every MF), digging on a thousand kinds of robots, taking on challenges at the Instructables booth, spending way too much time at the various Legos exhibits, eating great good food on a perfect spring day. And the R2D2 Miles wanted so badly to see last year finally showed up – the little Padouin was beaming with happiness.

This year’s photo gallery (63 images and 10 videos):

Click icon at lower right after starting to view full-screen.
View the whole set at Flickr (includes captions you don’t get with the slideshow).

See also: my photos from Maker Faires 2008, 2007 and 2006.

That’s OK. Now we’ve got two years to ramp up a properly prepared campaign for the 2010 elections, in which we can upend this topsy turvy, nonsensical situation and restore reason and compassion to our state.

Courage Campaign has launched a pledge campaign to overturn Prop 8 by 2010. It may take all we can muster to turn this around, but it’s the duty of every person who considers themselves a fair, honest human being with a basic, non-negotiable conviction in basic equal rights. Please join us.

This excellent Fidelity video is already starting to air on TV across the state:

Chakarova has spent more than six years reporting on sex trafficking in Eastern Europe and parts of the Middle East. The site features a series of interviews with young women sold into prostitution against their will, multimedia video pieces, reporting notes, previous work that launched on PBS’ Frontline/World, NGO resources and ways to get involved. Chakarova says:

Please spread the word and leave comments on the site. Your input is invaluable. And as always, I am grateful for your support and interest in my work.

Roger Moore on the appearance of Metallica’s Lars Ulrich on the Rachel Maddow Show: Heavy Metal Drummer.

Scot on the greatest prog rock band you’ve never heard of: The mythical Gemini Rising takes to the web’s faux airwaves.

An “event” can last any number of days, and can include any number of presentations, each of which may or may not include a webcast. While the event is in progress, you want the ability to advertise a single URL, where all of the live webcasts will happen. But for the archives, which is where the vast majority of viewing happens over the course of time, you want a separate page/URL for each presentation. Presentation pages include details on that speaker, summaries of what was presented, and optional downloads of PowerPoint or Keynote presentations. Our Presentation model is foreign-keyed to a master Event model (or, in our case, the Workshop model).

Because they’re time-based, synchronous events, webcasts are different from typical web pages. There are five possible “states” a webcast page can be in at any given time, all of which require different things to be inserted into the view:

Upcoming: The event is announced but there’s nothing yet to show. Tell user that webcast will be live at posted time (along with schedule).

In progress: The event is occurring. Insert appropriate object code to embed live QuickTime stream.

Concluded: The live webcast has ended, but the archives haven’t yet been prepared and posted (this can take us a few days). Tell user to come back soon.

Archive: The archived video is prepared and available on the streaming server for posterity. Insert appropriate object code to display streamed archive file from QuickTime Streaming Server.

External: We sometimes host events at other locations on campus, in which case UC Berkeley handles the webcasting rather than us. If so, we need to link from our events database to theirs. Insert appropriate message and link.

In Django, we represent these choices with the typical CHOICES construct:

webcast_state = models.CharField(max_length=4,choices=WEBCAST_STATE_CHOICES)

… which ends up looking like this in the Django admin:

Depending on the current state, different content (text or object/embed code) is inserted into the page in real time (using simple conditionals in Django templates). The Django admin thus becomes a handy tool our student helpers can use to make the master workshop page embed the right thing in the right place at the right time without requiring tech skills. Remember, during the course of a workshop week, all video is happening in the master Workshop page – later, streaming video archives will go into separate Presentation pages and be automatically linked to from the parent Workshop page.

Stream Handles

At the J-School, we use QuickTime Streaming Server, in part because it’s free, and in part because all of our  workstations and most of our servers are Macs. We’ve contemplated switching to Flash streaming, but the simplicity of keeping everything Mac-native keeps us on QTSS for now.

Embedding a stream from an external QTSS server is not quite as straightforward as embedding a typical QuickTime movie. Video comes from QTSS over the rtsp:// protocol, rather than http://. And there’s the catch: You can’t embed an rtsp stream directly into a web page — instead, you need to embed a fake QuickTime movie (a “reference movie”), which is actually a text file with the .mov extension. That text file simply references the full URL of the rtsp stream coming from QTSS. The contents of a reference movie file might look like this:

<?xml version="1.0"?>
<?quicktime type="application/x-quicktime-media-link"?>
<embed src="rtsp://streamer.domain.edu/events/131.humanity_2.0.mov" />

Here’s where things get interesting as far as Django is concerned. We don’t want to have to create a physical reference movie for every single stream we serve. And yet, at the HTML level, we have to embed something that looks like a reference to a physically external movie file, e.g.:

<object classid="clsid:02BF25D5-8C17-4B23-BC80-D3488ABDDC6B" 
 width="480" height="376" 
  codebase="http://www.apple.com/qtactivex/qtplugin.cab">
 <param name="SRC" value="/presentations/webcast-archive.227.ref.mov">
 <param name="AUTOPLAY" value="true">
 <param name="CONTROLLER" value="true">
 <embed src="/presentations/webcast-archive.227.ref.mov" 
  width="480" height="376" autoplay="true" controller="true" 
  pluginspage="http://www.apple.com/quicktime/download/">
</object>

So how can we make Django think that /presentations/webcast-archive.227.ref.mov is an actual file on the server, which in turn contains the correct reference to the rtsp stream coming from the streaming server? In effect, it’s a “view within a view.”

Click for larger version

Displaying the presentation page is straightforward Django – I won’t get into that here. But here’s how the “view within a view” stuff works. In the object section of the presentation page template there is a reference to:

<param name="SRC" value="/presentations/webcast-archive.{{object.id}}.ref.mov">

which resolves to something like:

<param name="SRC" value="/presentations/webcast-archive.267.ref.mov">

When the browser hits that line, it requests /presentations/webcast-archive.267.ref.mov from the server, which in turn triggers this entry in urls.py:

url(r'^presentations/webcast-archive.(?P<pres_id>\d+).ref.mov$',
'workshops.views.presentation_webcast_archive',
name='workshops_presentation_webcast_archive'),

So after the presentation page has been rendered by Django and sent to the browser, a second (very simple) view, presentation_webcast_archive, is called, which is simply:

def presentation_webcast_archive(request, pres_id):
    """
    Generate a virtual QuickTime reference movie on the fly,
    to be embedded in presentation webcast pages.
    """

    pres = get_object_or_404(Presentation,id=pres_id) 

    return render_to_response( 'workshops/presentation_webcast_archive.txt',
        {
            'p': pres,
        }, context_instance=RequestContext(request),
    )

That view spits out the same presentation object to a different template, presentation_webcast_archive.txt, which consists of:

<?xml version="1.0"?>
<?quicktime type="application/x-quicktime-media-link"?>
<embed src="rtsp://domain.edu/events/{{p.webcast_path}}/{{p.webcast_filename}}" />

Where webcast_path and webcast_filename are fields on the model representing the physical location of the QuickTime media on the streaming server (not the web server). After a workshop week is over, staff only need to hint the saved archive files, upload them to a directory and filename on the streaming server, enter those paths in the Django admin, and check the “Has Webcast” box. The rest is automatic.

In a previous, PHP-based version of this system, we had to prepare an actual reference movie for every archive stream we hosted. By using this “view within a view” technique, Django has let us remove that part of the workflow.

After clicking Play button, click icon at lower right of slideshow to view full-screen.

Flickr set

“A ball of fluff falls into a black hole, and out comes me, a ball of fluff!”

I’ve found that some charcoal enthusiasts think gas grills don’t produce smoke at all… which is absolutely not true. A gas grill is not an oven! The smoke from gas grills can be voluminous (even scary), and comes from the burning off of fats and drippings from meat, as well as the carbonized residue of previous grilling sessions. Yep, it’s a different kind of smoke from charcoal smoke, but it’s definitely smoke.

Our family are gas peeps – we sort of skipped the charcoal phase and went straight for convenience. For us, the gas decision was partly environmental, wanting to sidestep or reduce particulate emissions that come from burning wood, for the same reason newer houses don’t even come with fireplaces.

Charcoal grills emit more carbon monoxide, particulate matter and soot into the atmosphere, contributing to increased pollution and higher concentrations of ground-level ozone.

In fact, in Canada, charcoal is now a restricted product under the Hazardous Products Act. But the carbon footprint question is more complicated than it appears on the surface – charcoal may come from renewable forests, which in turn consume the same amount of CO2 as the grills they fuel produce. Then again, a lot of charcoal products are infused with chemicals to make it easier to light, burn longer, etc. Slate has a great piece on the environmental factors in the gas vs. charcoal question.

Then there’s the cost factor – gas grills cost more, but reqire far less expenditure on fuel – a round of charcoal cooking can cost up to $5.00 in briquettes, while gas might clock in at around $0.50 per session.

OK, poll time – do you do gas or charcoal? Let me know in the comments whether you can taste the difference.

Here’s a pretty good side-by-side comparison chart, though it conveniently skips the environmental factors.

Email: queen5050pil@ymail.com
Message:
pls are you a hacker, if yes pls can you get for me cc with the balance and ATM pin visa and master cards or can you hack into any bank system mostly nigerian banks, pls reply asap thanks.

Srsly.