@future
static void doFutureCall(List<AddressHelper> addresses) {
  //do something
}

But thankfully there is a way you can do. The secret sauce is the JSON serialize|deserialize methods.

Take the example of an AddressHelper object referred to above. This is encapsulated convenience object to help me pass around address details. (note:For simplicity, this helper object just includes strings, but it could easily include other types including objects, sobjects, collections etc.)

/**
 * Sample encapsulated class
 * $author: qwall@salesforce.com
 */
public with sharing class AddressHelper {

	public String street {set; get;}
	public String city {set; get;}
	public String state {set; get;}
	public String zip {set; get;}

    public AddressHelper(String s, String c, String st, String z) {
    	street = s;
    	city = c;
    	state = st;
    	zip = z;
    }
}

Using the JSON serialize method I can easily pass this to an @future method.

public with sharing class AddressFuture {

    public AddressFuture () {

	List<String> addresses = new List<String>();
	AddressHelper ah1 = new AddressHelper('1 here st', 'San Francisco', 'CA', '94105');
	AddressHelper ah2 = new AddressHelper('2 here st', 'San Francisco', 'CA', '94105');
	AddressHelper ah3 = new AddressHelper('3 here st', 'San Francisco', 'CA', '94105');

	//serialize my objects
	addresses.add(JSON.serialize(ah3));
	addresses.add(JSON.serialize(ah2));
	addresses.add(JSON.serialize(ah3));

	doFutureCall(addresses);

  }

And then, within my future method, all I need to do is deserialize the object, and you are good to go.

  @future
    static void doFutureCall(List<String> addressesSer) {

    	AddressHelper currAddress = null;

       for (String ser : addressesSer)
       {

       	 currAddress = (AddressHelper) JSON.deserialize(ser, AddressHelper.class);
       	 System.debug('Deserialized in future:'+currAddress.street);
       }
    }

That’s it. JSON.serialize|deserialize makes it amazingly simple to pass objects, even ones with complex nested relationships, to @future annotated methods. There are time though that a particular object can not be serialized due to the underlying inheritance structure. One such example is the Pattern class in Apex.

To handle these outliers, I often create my own custom getSerializable() method on my custom object. For example, I use this strategy within the Chatter Blacklist app to pass a patternHelper object to an @future method.

/**
     * return a serializable version of the patternhelper
     */
    public PatternHelperSerializable getSerializable()
    {
    	//instead of passing the Pattern object, let's just pass the regex string from
        //via Pattern.pattern() method
    	return new PatternHelperSerializable(blacklistedWord, p.pattern(), origPostBody, postCreatedById);
    }

That’s about it. You can grab the complete code for the examples above as a gist here.

There’s another huge milestone Apple has passed: apps in the Apple App Store now average more than $10K total revenue per app.  There is of course a distribution with some runaway hits and a long tail. An expected payout of $10K, and an exciting blowout head of multi-million dollar apps will inspire many long nights of developers hacking to build the next big thing.

We love the app revolution, and we are convinced it’s already hit the enterprise as well.  Salesforce.com has built the leading business apps marketplace with the AppExchange, touting more than 1800 apps for business to date.  We don’t do Angry Birds. But we do know that enterprises want social, mobile and connected apps and they are willing to pay for them.  The average developer on the AppExchange makes $392,000 per app.  That’s right, almost $400K from companies including 70% of the Fortune 100. And what’s great about selling these next generation apps to businesses is that a single install in our world can sometimes account for tens of thousands of users!

We are embracing the enterprise app revolution, and we love developers. That’s why we’ve paid more than $750M to developers since we launched the AppExchange.  And it’s accelerating.  If you want to be part of this revolution, you can start today for free.

• If you finish 1 challenge, you will win a cool Force.com t-shirt
• If you are 1 of the first 10 people to complete 2 challenges, you will win a set of hot Beats by Dre headphones
• If you finish all 3 challenges, you  will be entered into a raffle for a sweet MacBook Air

With requisite apologies to Mr. Thorogood, the Big Apple DevZone is right around the corner.  We’ll be hosting a Dev Theater, an Intro Workshop and of course the ever popular Mini-Hacks.

Register for the June 14 NYC DevZone Today

The Intro Workshop is built around the Force.com Intro Workbook.  It’s a great hands-on tour of the Salesforce Platform designed for people who want to dive right in.  Each session is first come, first served, and lasts 45 minutes.  We even provide a laptop.

• 8:30 — Create an App and Database
• 11:40 — 100: Create an App and Database
• 12:30 — 110: Customize a User Interface
• 1:20 — 120: Add App Logic with Clicks not Code
• 2:10 — 300: Code Custom App Logic
• 3:00 — 330: Code a Custom User Interface
• 3:50 — 475: Force.com API Integration with Apex and Heroku

This is a great line up!  Be sure to register today and join us on June 14.  I look forward to seeing you there.

PS If you aren’t convinced yet, be sure to checkout pictures from London and Paris.  The DevZone is not to be missed!!

Since the prehistoric times tools have played a vital role in human life. Starting from early tools like hammerstones and handaxes to modern day tools like the Airplane, the Internet, and mobile apps, tools have constantly changed the World and are continuing to do so.

The thing about tools is that their mere existence is to help its users achieve something quickly and easily or to solve a problem. This applies to all kinds of tools irrespective of whether we are trying to find cure to a disease or cooking food or building a mobile app.
But nothing is free in this world, tools included. Tools, while useful pose the following challenges:

• There could be many of them that do the same thing.Making them hard to even discover
• Not all of them are created equal. It takes time to find the best and preferred tool
• They work when used in the right context. I.E. “Don’t use sword to cut nails”
• They all have learning curves (big or small)
• They all hide tips and tricks (or best practices). You need to use them to know them and take advantage of them.

While tools might pose challenges, history has shown that those who have built/discovered the tools and have mastered the art of how to use them effectively have ruled the World (in their own right). For example those who have mastered fishing hooks have not only survived but have thrived in harsh weather conditions. Similarly those who were great at swords and other weapons have won battles and wars.

Tools play a similar role in every field but the number of tools you need depends on the complexity of the task you are trying to achieve. Developing a mobile app being a relatively complex task, it demands usage of many other tools. And that in turn makes knowledge and expertise of tools that much more important.

So if you are developing software, don’t just use few features of a tool but make sure to set aside enough time to discover as much as you can and figure out tips and tricks associated with them.

Tips on mastering tools:

1. Search for “top tools for doing xyz” and try few of them and see which one does the best job AND which one you are comfortable with.
2. Several tools come with “Tips and Tricks” dialog boxes. Don’t turn them off it is there to help you (although it could be little annoying).
3. Search for “tips and tricks on using xyz” online.
4. Many tools come with plugins to enhance their capabilities. Search for plugins and try them out.
5. Many tools have ‘keyboard shortcuts’ or other shortcuts. Don’t try to learn them all at once – they are like dieting take it slow and steady. Generally try to learn just 1 shortcut per week.
6. Stick with one tool but keep on the lookout for better tools

Tools to interact with Salesforce database:

In this blog we will cover #1 and list tools to interact with Salesforce and will cover the rest in the future blogs.

1. Workbench (http://wiki.developerforce.com/page/Workbench)

Just a like a real workbench, Workbench is designed to be an application administrators and developers can use to quickly view their organizations’ data and metadata, test and troubleshoot their own applications, and be a one-stop shop for interacting with the various Force.com APIs.

(Click on the pics to zoom in)

 
2. Query Editor (Salesforce Query Editor)

Salesforce > Your name > Developer Console > Query Editor tab. This tab is part of Salesforce Developer Console and allows you to quickly run some SOQL queries. This can come in handy if you have already opened Developer Console for debugging or testing Apex code.

 
3. PocketSoap’s SoqlX (http://www.pocketsoap.com/osx/soqlx/)

SoqlX is a tool for developers using the Salesforce.com platform, it allows you to easily explorer your schema, write and run SOQL queries, make edits to data, and to run Apex code.

4. DEV HTTP Client Chrome Browser plugin (DEV HTTP client Web store url)

This is one of my favorite Chrome browser plugins. I’ve been using to quickly test http requests for Salesforce and other services for a long time. One thing that comes in really handy is that it stores all your queries so you can come back and reuse or make a little change and reuse instead of typing entire queries.

5. Ajax toolkit shell (aka Debug Shell) (https://login.salesforce.com/soap/ajax/27.0/debugshell.html)

A lightweight online tool also allows you to perform regular SOQL, SOSL queries. It comes with auto-complete and most of the operations are under sforce.connection and sforce.sObject. We use this the most when we need to quickly get hold of ‘sessionId’.

For example: To get sessionId, simply login to https://login.salesforce.com/soap/ajax/27.0/debugshell.html and type: sforce.connection.login(yourEmail, yourPwd); and hit enter. You’ll see something like below: 

6. CURL
Good old cURL remains extremely popular among linux/mac developers. You can obviously do any kind of http requests to query Salesforce or any other services. Here is couple of examples of how you can use cURL against Salesforce:

• Get SessionId via POST:

See http://www.salesforce.com/us/developer/docs/api_asynch/Content/asynch_api_quickstart_login.htm

• Get two contacts:

  curl -H 'Authorization: OAuth  YOUR_SESSION_ID https://na15.salesforce.com/services/data/v20.0/query/?q=SELECT+name+from+Contact+limit+2'

curl -H 'Authorization: OAuth YOUR_SESSION_ID' -H 'X-PrettyPrint:1' https://na15.salesforce.com/services/data/v27.0/query/?q=SELECT+name+from+Contact+limit+2

{
  "totalSize" : 2,
  "done" : true,
  "records" : [ {
    "attributes" : {
      "type" : "Contact",
      "url" : "/services/data/v20.0/sobjects/Contact/003i0000005zwGpAAI"
    },
    "Name" : "Rose Gonzalez"
  }, {
    "attributes" : {
      "type" : "Contact",
      "url" : "/services/data/v20.0/sobjects/Contact/003i0000005zwGqAAI"
    },
    "Name" : "Sean Forbes"
  } ]
}

Now those are the main tools available to interact with Salesforce database. Internally the unofficial popularity of these tools are in the following order #1, #6, #5, #2, #3, #4. Go ahead and use the tips mentioned earlier to pick few of them and see which one works the best.

As I mentioned earlier, I will cover other tools, tips and tricks related to developing mobile apps on Salesforce.

Finally, remember tools are there to help you and it is as important to learn about tools as learning programming languages and design.
- Cheers!
Raja (@rajaraodv)