code: function( self, callback, opt, async ) {
              opt = opt || {};
              self = self || opt.self;
  
              if ( opt.async ) {
                  async = true;
                  delete opt.async;
              }
  
              if ( async ) {
                  g.Crisp.nextTick( utilTickCall, callback, self, opt );
                  return self;
              }
              else {
                  utilTickCall( callback, self, opt );
              }
  
              return self;
          }
docs: execute function with (async) {@link util.utilTickCall}
  
  @deprecated change to {@linkcode module:BaseJS.utilTack|Crisp.utilTack( opt, success, complete )}
  
  @param       {external:Object}         [self=opt.self] alternate of opt.self and return param
  @param       {util.utilTickCallback}   callback        Function for apply
  @param       {external:Object}         [opt]           Options for apply
  @param       {AnyItem}                 [opt.self]      thisArg of apply
  @param       {AnyItem}                 [opt.args]      Arguments for apply
  @param       {external:Boolean}        [async=false]   Asynchronus apply
  
  @this        module:BaseJS
  @return      {self}
  
  @memberOf module:BaseJS
  
  @tutorial {@link http://opencrisp.wca.at/tutorials/BaseJS_test.html#utiltick|use utilTick}
  
  @example <caption>synchronous execution of an anonymous function</caption>
  Crisp.utilTick({ a: 'A' }, function() {
  console.log(this);
  });
  console.log('end');
  // logs:
  // { "a": "A" }
  // end
  
  @example <caption>asynchronous exetution of an named function</caption>
  function test( b ) {
  console.log( b.c );
  }
  
  Crisp.utilTick( { a: 'A' }, test, { args: 'C' }, true );
  console.log('end');
  // logs:
  // end
  // { "a": "A" }