Application Process

Primarily, what you need to understand is that the child has to apply personally, along with a guardian or both parents. Renewal of passports through the mail is not applicable for minors. Children below the age of 16 whose passports have expired or are about to expire should apply for renewal by filling out the form and submitting it personally at the designated center.

Form DS-11

The form should be completed but it is signed only after the request of the agent. Form DS-11 is required to apply for a passport if you are U. S. A citizen. The complete but unsigned form must be presented to an agent at a passport accepting facility. Parental consent is also necessary for children under the age of 16. There is a different form for expedited American child passports.

Documentation

If you are applying for a minor, a proof of citizenship needs to be presented along with evidence of the relationship between the parents or guardians and the child. You should also present the child’s birth certificate as primary evidence.

Proof of Relationship

To present a proof of your relationship with the child, you have to provide a birth certificate that clearly states the parent’s name or an adoption decree that has the adopting parents’ names on it. In other situations a court order authorizing you to have the custody or guardianship of the child can also be presented.

Foreign Birth

In case your child was born abroad, you would have to provide a certified foreign birth certificate with the parents’ names and a translation if required. A document of certification of birth abroad may also be used. Minors under sixteen, apart from needing evidence of the relationship between them and parents, will also have to provide copies of their parents’ identification plus a photocopy of each parent/guardian document.

Parental Consent

What does it mean to provide parental consent for children to get U. S. Passports? It means being there with the child in front of the responsible agent who authorizes the passports. If only one parent can appear, the other must have written a statement that is notarized giving his or her consent. Once again, sole legal custody must be documented by a custody decree from the courts or a death certificate.

Download The Application

The main benefit of this is being able to complete the process at short notice. Often when you are travelling, there is a lot of preparation and even important details can be forgotten until the last minute. Applying for a 24-hour passport for your child is a real time saver. However in order to make sure the process is successful, you need to provide the right information and have the right forms.

Parental Consent

The next step is to make sure you have the proper identification for your child. A birth certificate is the preferred document to be used for this purpose. If you have an expired passport for your child, you can also use it as a form of identification if it is in good condition. Another important requirement is that both parents or guardians must be present or must provide a notarized letter providing permission for the child’s travel.

Identification

Equally important is having the correct identification. You should have your birth certificate to hand so a copy can be made. If this is not available, it is possible to use an expired previous passport as long as it is in good condition.

Proof of Travel Date

The problem of an absentee parent is easily overcome by providing written consent allowing the child to travel. Remember that this letter must be notarized. It is also vital to have two passport photos. These must be taken in accordance with all government rules and regulations for passport photos. You also need to present proof of the departure date. This can be in the form of a ticket or travel itinerary.

Submission of Documents and Fees

If you are travelling for business purposes but need to take your children with you, you may need to have a letter from your employer to verify the urgency of your departure. With the proper documentation, you will have no problem receiving your child’s travel documents in time for your departure.

Receipt of Your Completed Documents

Once the expedited US passport forms have been completed, you will pay the relevant fees. These fees will include governmental fees as well as expediting charges, which will be paid to the agency assisting you. When you receive your completed documents, they must remain in the sealed envelope until presented to the agency processing them for you.

I think Jimmy put it the best when he said: “Yeah, I read your posts but there just wasn’t a whole lot of code”. So this time I’m going to write a post that’s mostly code and see if it helps.

Show me something concrete

Let’s start with an example and then I’ll explain what’s going on:

If you run this example, you’ll be shown a dialog. Clicking “Success” or “Failure” will demonstrate the behavior of a successful or failed http post (respectively).

NOTE:
I’ve noted this in the code several times but here it is again: don’t bother with the “Server” stuff. It’s just a helper to mock the ajax calls since we’re not using a server here.

Custom options

We are making use of the correlatedSubmit method here (an extension to jquery.forms). Notice that we’re passing in the custom “closeDialog” property.

Passing in a hash to correlatedSubmit or as the “options” property of the hash to $.ajax provides a local set of custom options that are made available during the processing of the clientside continuation.

Great, what does that mean? Well, here’s how this works:

Whenever a continuation is received (via the success callback from $.ajax), this custom dialog policy will be inspected. Notice that we’re matching against “continuation.options.closeDialog”. The options property of the continuation contains the same options that you passed in so in this case, “closeDialog” would be true.

Note:
My first pass at this didn’t have these custom options and our conventions were ALWAYS global. You should ask Jeremy what he thought about that.

In case you missed the point here, our policy conventionally closes a jquery ui dialog when the response was successful.

Reusable conventions

Conventions are only “conventions” when they’re reusable. Reusable pieces of code really strut their value when they’re reusable in more than one project.

The “Failure” button demonstrates a failed continuation response from the server. fubuvalidation-js has a built-in convention for detecting those errors and rendering them into the form that originated the request. So simply including fubuvalidation-js into this jsfiddle was enough to get that to work.

From client to server

The validation and “close dialog” policies are pretty useful. For us, they’re very useful because we use them throughout our app. These are just two simple examples of what can be done here. Let’s brainstorm a few more to make sure I’m articulating the power of this correctly:

• Refresh the page (force a full refresh on certain conditions)
• Redirect to a new url
• Display errors (“something went terribly wrong”)
• Keep track of pending ajax requests

The list goes on and on but let’s talk about this “redirect to a new url” idea.

APIs and Continuations

A common technique found in HTTP-based APIs is to provide a set of information regarding a resource when it is created. For example, “POST /users/create” may return things like:

• The ID of the User
• Some urls (e.g., “go here to view the details”, “go here to edit the user”

If you design your endpoints to follow a similar technique, you can plugin policies that use the response and orchestrate the behavior of your system from a central block of code. Of course, in small applications this doesn’t pay off but in large and complex systems the value starts to shine.

Wrapping it up

Hopefully the code speaks for itself and this sparks a few ideas.

Los Techies

• Bandwidth reports (created by Hyper-V Bandwidth Meter) are now provided to view with Hosting Controller.
• In case of bandwidth over usage, Hosting Controller will take appropriate action (configurable) e.g. Suspend Virtual Machine, Resume Virtual Machine.

Hosts Tools

Alcohol

Alcohol can be a highly addictive substance and individuals with drinking problems often have difficulty with family and work relationships. Sometimes they may encounter serious legal problems, especially if they drink and drive. Some young people are compelled to attend rehabilitation because of part of a court ordered sentence. Others may come voluntarily. It is important for them to confront the problem early, as alcohol dependency that goes untreated can lead to future health problems.

Detox

Counseling and detoxification are two important parts of a rehabilitation strategy. Initially, patients may need to detoxify and sober up before they can respond to treatment. Once this takes place, therapeutic counseling can help the patient make the necessary changes. However, counseling and other forms of therapy usually can not begin until the patient has gone through the detoxification process.

Dependency

Detoxification becomes necessary in many cases for people who are dependent on alcohol. These people may experience significant withdrawal symptoms including in some cases life threatening delirium tremens. DTs are characterized by convulsions, hallucinations and blurred consciousness. Persons suffering from intense withdrawal symptoms often require residential treatment so that they can be monitored for rapid changes in health. Sometimes the administration of tranquilizers such as Ativan or Valium might be recommended.

Support Groups

Many rehab programs follow the twelve step program outlined by Alcoholics Anonymous. However, not every facility employs this model and there are other therapeutic approaches to recovery. Although programs differ in design, all of them are designed with the goal of getting the patient sober and keeping him or her sober for the long haul.

Residential Care

Some people may need inpatient care for their addiction while others can go outpatient. It is all up to the doctor who sees the patient and determines what they may need. In a residential program, several professionals will work with a patient to help them recover. Outpatient treatment may have less doctors as it requires less maintenance.

Consequences

There are several repercussions for having an alcohol problem. It can affect one’s personal relationships, work history and stability, and one’s health. Of course, all of these are important to having a healthy life. Rehabilitation facilities help bring about change and health for people of all ages. A patient must want the change, however. No one can make them change unless they want it. The goal is sobriety living.

Held for the sixth year in a row, the goal of the 2012 Benchmark Survey is to assess hoteliers’ 2012 digital marketing priorities, as well as provide the industry with insight into recent evolutions in digital marketing strategies.  The results and analysis of this survey, provided by HeBS Digital, may assist hoteliers in building better ROI-centric, cost-effective digital marketing solutions to help meet and exceed their goals.

Key findings from the 5^th Annual Benchmark Survey conducted in 2011 can be found on the HeBS Digital blog.

The survey should take no more than five minutes to complete, and all participants will be entered to win a Google+ Business Page Set-Up and a Facebook Custom Tab Design.

“HeBS Digital launches this survey year-after-year for two reasons: to provide the hospitality industry with results and actionable recommendations, and to assess the annual changes in hoteliers’ priorities, digital marketing budgets and industry dynamics,” said Max Starkov, President and CEO of HeBS Digital. “The following affect budget planning for hoteliers: the state of the economy, technological advancements (and their adoption by consumers), changes in search engine algorithms, emerging distribution channels such as the mobile web and customer engagement channels like Facebook, Twitter, etc. The Benchmark Survey helps us evaluate how these issues affect and influence hoteliers, and how their properties will react to the new competitive landscape.”

General managers, revenue managers, sales and marketing managers, e-commerce managers and professionals at hotels, resorts, hotel management companies and hotel chains are invited to participate in the 2012 Benchmark Survey on Hotel Digital Marketing Strategies, Budget Planning and Best Practices. Please click here to take the survey.

About HeBS Digital:

Founded in 2001, HeBS Digital is the industry’s leading full-service hotel digital marketing, website design and direct online channel strategy firm based in New York City (www.HeBSDigital.com).

HeBS Digital has pioneered many of the “best practices” in hotel digital marketing, social and mobile marketing, and direct online channel distribution. The firm has won over 175 prestigious industry awards for its digital marketing and website design services, including numerous Adrian Awards, Davey Awards, W3 Awards, WebAwards, Magellan Awards, Summit International Awards, Interactive Media Awards, and IAC Awards.

A diverse client portfolio of top tier major hotel brands, luxury and boutique hotel brands, resorts and casinos, hotel management companies, franchisees and independents, and CVBs are taking advantage of the hospitality digital marketing expertise offered at HeBS Digital. Contact HeBS Digital’s consultants at (212) 752-8186 or success@hebsdigital.com.

Editorial Contact:
Mariana Mechoso Safer
HeBS Digital
Phone: 212-752-8186
Email: mariana@hebsdigital.com
Web: http://www.hebsdigital.com
Facebook: http://www.facebook.com/hebsdigital
Twitter: https://twitter.com/HeBS_NYC
LinkedIn: http://www.linkedin.com/company/hospitality-ebusiness-strategies
 

HeBS Internet Marketing Blog

For my smaller applications, I tend to stuff a number of <script> blocks in to the HTML that the user downloads. This makes it easy for me to work with and I don’t have to worry about whether or not the template exists. But when the number of templates gets to be more than 5 or 6 small ones, this gets out of hand quickly. It makes it hard for me to manage them as I have to scroll through a lot of template code. Putting them in external files and then including them in the page with some server side technology helps the developer problem but it doesn’t solve the client problem of having to download all of these templates even if they are never used.

To deal with the issues surrounding templates in HTML files, we can split our templates in to separate files and then use asynchronous calls to our server to load them as needed.

Backbone.View Render Semantics

One of my goals, other than the asynchronous template loading, is to keep the general semantics of a Backbone View’s `render` method. It’s a short list, but it’s an important list as most of the Backbone community expects the render method to work this way.

Semantics are generally important as they give us information about how methods and objects are expected to be used, as well. This, in turn, informs the method signature and behavior. And all of this comes back to the Liskov Substitution Principle (LSP) from the SOLID principles, which tells us that we need to pay attention to semantics so that we can drop in replacements as needed.

The general semantics and method signature of a view’s render include:

• No parameters: the render method shouldn’t require any parameters. You should be able to call `view.render()` and have it work fine
• Chainable: the render method should return `this` so that it can be chained with other method and attribute calls. This is most commonly done as `view.render().el` to grab the element that was rendered to
• Populate `el`, don’t replace it: the render method should populate a view’s `el` with any contents that the view needs to display. It generally shouldn’t replace the `el` as a whole

Aside from these three items, there’s a lot of flexibility in how a view will typically be rendered. There’s also plenty of room for interpretation and divergence from this list. Many applications use a render method signature that takes parameters, or that replaces the `el` entirely. When changes like this are made, it’s a good idea to document them so that people will know why the changes are in place.

The benefit of keeping these semantics, though, is that you can swap out a synchronous, pre-loaded template rendering view with a view that uses an asynchronous template loading mechanism. Or, better yet, you can have an intelligent system that uses asynchronous calls to get the template the first time it needs it, and then uses caching to keep the template around and do synchronous rendering on subsequent requests for this view / template. If the semantics for the view are kept in place, it doesn’t matter how the view implements the rendering. The view can be dropped in or removed as needed, without having to change the surrounding code that uses it.

Simple Async Template Retrieval

We can keep this very simple, to begin with, using jQuery’s AJAX calls to load the template with a callback to do the actual rendering after the template is loaded.

Backbone.View.extend({
  template: 'my-view-template',


  render: function(){
    var that = this;
    $.get("/templates/" + this.template + ".html", function(template){
      var html = $(template).tmpl();
      that.$el.html(html);
    });
    return this;
  }


});

In this example, we’re assuming that the view has a `template` attribute. This attribute represents the file that will be loaded from the server, and that file contain the actual template to be used.

We’re also using a convention of `/templates/{name}.html` for the template location on the server. This can be implemented easily in many different web server technologies. In Sinatra, for example, you can create a “public/templates” folder and put your HTML template files directly in that folder. They will be available without having to do anything more than start the Sinatra server.

When the call to `render` is made, the code makes an AJAX call back to the server to retrieve the specified template. A callback method is provided – and at this point, it assumes a successful call to get the template. When the template is returned from the server, the callback is fired, and the standard render code (using jQuery templates in this example) is executed.

Note that the `el` for the view is populated inside of the callback, but we are still calling `return this` at the end of the function. Even if we chain access to the `el` from the `render` method and immediately add the el’s contents to the DOM, this will still work:

$(“#content”).html(view.render().el);

The reason this works is that we are only populating the `el` with contents. We are not replacing it. When the AJAX call finally returns with the template, rendering it and populating the `el` will show the contents immediately because we’re setting the `html` method of an HTML element that is already attached to the DOM. It’s as if we had called `$(“#content”).html(“<div>some html</div>”);` directly.

Caching Templates

Now that we have a template loading asynchronously, it would be nice to only load it once instead of every time it needs to be used. This will improve the overall performance of the application, from the user’s perspective.

To do this, we’ll need a little more than just some code in the render method. We want to re-use templates that we’ve already loaded, which means we can’t just store the template on the view instance. We need to store it in a place where any view instance can grab a copy of the template if it exists, or have an asynchronous call back to the server done to get the template when needed.

TemplateManager = {
  templates: {},


  get: function(id, callback){
    var template = this.templates[id];


    if (template) {
      callback(template);


    } else {


      var that = this;
      $.get("/templates/" + id + ".html", function(template)){
        var $tmpl = $(template);
        that.templates[id] = $tmpl;
        callback($tmpl);
      }


    }


  }


}

The template manager object has one primary method that we call: `get`. This method takes in a template name to be loaded and a callback method that is executed when the template is found. By using a callback method instead of returning a value directly, we can ensure both synchronous and asynchronous calls will work correctly.

When you call `get`, it will check a hash / object literal to see if the template you want is already loaded using the template name that you provide to make this check. If it exists, it executes the callback immediately and passes the template along. If it does not exist yet, an AJAX call is made with jQuery to get the template from the server. Once the template is loaded, the callback that you passed in will be executed and the template is passed to it.

We can now update our view to use the template manager:

Backbone.View.extend({
  template: 'my-view-template',


  render: function(){
    var that = this;
    TemplateManager.get(this.template, function(template){
      var html = $(template).tmpl();
      that.$el.html(html);
    });
    return this;
  }


});

This isn’t much of a change from the view’s perspective. It’s better encapsulated, though, and a little easier to read. The real work is now being done in the TemplateManager object and we can change how it behaves as needed without having to update our views.

Beyond Simple Caching

There’s one remaining problem that this code has. If you have multiple instances of a view requesting the same template at roughly the same time, multiple AJAX calls will be made – one for each instance of the view. The net result is a slowdown in the application’s performance from too many network calls, and also a visual oddity where the views will appear one at a time as the AJAX calls finish. This can be a pretty big drag on performance and UI responsiveness.

Thanks to some previous digging in to jQuery’s deferred and some help from Steve Flitcroft (@red_square), I was able to solve this problem fairly easily. I put the following code in to my BBCloneMail app, which uses my Backbone.Marionette plugin. It’s not directly implemented in Marionette’s `TemplateManager` but most of what you need is already there. There’s only a few additional lines of code that you need to make this work.

(function(){
  var promises = {};


  // Cache the returned deferred/promise by the id of the template
  // so that we can prevent multiple requests for the same template
  // from making the ajax call.
  //
  // This code is only safe to run synchronously. There exists a
  // race condition in this function, when run asynchronously,
  // which would nullify the benefit under certain circumstances.
  var loadTemplateAsync = function(tmpId){
    var promise = promises[tmpId] || $.get("/templates/" + tmpId + ".html");
    promises[tmpId] = promise;
    return promise;
  }


  // Use jQuery to asynchronously load the template. 
  Backbone.Marionette.TemplateManager.loadTemplate = function(templateId, callback){
    var tmpId = templateId.replace("#", "");
    var promise = loadTemplateAsync(tmpId);
    promise.done(function(template){
      callback.call(this, $(template));
    });
  }
})();

The basic idea is that I’m using a jQuery deferred / promise to fire the callback method from the loadTemplate parameters. To prevent multiple requests for the same template heading back to the server, I’m caching the promises by the template id. When a call to loadTemplate is made through the template manager, I check to see if I have a promise for that template already. If I do, I register the loadTemplate’s callback parameter with the promise. If I don’t, I create the promise and then store it by the template’s Id. Either way, I register the callback with the promise which guarantees it will be executed. Once the template is returned from the server and the promise is fulfilled (resolved), all of the callbacks are fired off with the template data and everything renders correctly.

Note, though, that this code is not 100% safe. If you call the template manager from code that is already asynchronous, you can end up with a race condition where multiple promises are created and multiple calls to get the template are done. You’ll still get all of your views rendered just fine, but this will eliminate the benefit of using a promise to reduce network calls. Calling this code synchronously, though, won’t cause this race condition and the templates will only load once before they are cached and re-used.

See It In Action

If you’d like to see an example of this code in action (including the deferred/promise code from above), check out my BBCloneMail application and it’s source code. You’ll see the update to the TemplateManager’s `loadTemplate` function in the code. When you view the live site, switch to the Contacts view and refresh the page. There will be a small delay in the template loading, and then all of the contacts (which all individually requested the same contact template) will all display at once. Subsequent requests to those areas of the app will be cached, of course, improving the user experience and performance even more.

Los Techies