Node.js - A giant step backwards?(fennb.com)

    asynchronousCache.get("id:3244", function(err, myThing) {
      var useResult = function(err,_myThing){
          // We now have a thing from DB, do something with result
          // ...
      }
     
      if (myThing)
         useResult(null, myThing);
      else
         asynchronousDB.query("SELECT * from something WHERE id = 3244",useResult);

    myThing = synchronousCache.get("id:3244");
    if (myThing == null) {
      myThing = synchronousDB.query("SELECT * from something WHERE id = 3244");
    }

    myThing = database.lookup({'id':3244}, {'cache':cache_object});

    database.lookup({'id':3244}, {'cache':cache_object}, function(myThing) {
        // whatever
    });

    asynchronousCache.get("id:3244", function(err, myThing) {
      if (myThing == null) {
        asynchronousDB.query("SELECT * from something WHERE id = 3244", function(err, myThing) {
          // We now have a thing from DB, do something with result
          // ...
        });
    
      } else {
        // We have a thing from cache, do something with result
        // ...
      }
    });

   function f(x, result, error)
   function g(x, result, error)

   h = f o g

   function compose(f, g){
       return function(x, result, error){
           g(x, function(x_){ f(x_, result, error) }, error);
       }
   }

    result = { 'id': null, 'value': null, 'not_found': null }

    cache.lookup = function(key, result, error){
        new_key = key.copy();
        cache.raw_cache.lookup(key.id, function(value){
            new_key.result = value;
            new_key.not_found = false;
            result(new_key)
        },
        function(error_type, error_msg){
            if(error_type == ENOENT){
                new_key.not_found = true;
                result(new_key)
            }
            else {
                error(error_type, error_msg);
            }
        });
    };

    dbapi.lookup = function(key, result, error){ ... };
 

    cached_lookup = compose(dbapi.lookup, cache.lookup);
    cached_lookup(1234, do_next_step, handle_error);

    my_program = do([cache.lookup, dbapi.lookup, print_result]);

  asynchronousCache.get("id:3244", function doThing(err, myThing) {
    if (myThing === null) {
      asynchronousDB.query("SELECT * from something WHERE id = 3244", function(err, myThing) {
  		// We now have a thing from DB, do something with result
  		doThing(err, myThing);
      });

      return;
    } else if(err !== null) {
  	// Handle error.
  	return;
    }

  // We have a thing.
  });

    group (
        asyncfunc1()
        asyncfunc2()
        asyncfunc3()
    )

    getPosts (ids, cb) ->
        res = []
        stash = (err, post) ->
          res.push post
          cb(res) if res.length is ids.length
        db.getPostById(id, stash) for id in ids
        
    getPosts [...], (posts) ->
        # go on...

  getFromCache = function (id, callback) {
    asynchronousCache.get(['id', id].join(':'), function(err, myThing) {
      if (myThing == null) {
        asynchronousDB.query("SELECT * from something WHERE id = $id", {id:id}, function(err, myThing) {
          callback(myThing);
        });
      }
      else {
        callback(myThing);
      }
    });
  };

  getFromCache(3222, function (myThing) {
    console.log('myThing:', myThing);
  });