Moreover, even if we explicitly resist the clinging and clanging of the newest generation of digital beeps indicating new information that is available, we are likely to be drawn in or part of a digital resistance, which angrily decries all the new modes of information sharing.

Indeed, there is a logic to this. Very little information of the vast amount of new information available is valuable in and of itself. Some of this may be valuable in aggregate — I can find out, for instance, how many people talked about Justin Bieber this week on Twitter and how this corresponds to the number of people talking about any other pop artist. Other information is completely useless.

What are, however, the exceptions? As I see them, there are several “new” things emerging in this wave of technology:

(1) Extensibility
- I can reach people that I never could reach before. If I met someone once in China with a specific knowledge of acupuncture points on the foot, I can now easily reach out to him five years later when I have a specific question about foot massage. This is amazing and allows for greater hyper-specialization (by, among other things, empowering generalists at the same time)

(2) Connectivity
– I feel, or can feel, connected to people far away that previously I felt distant. This is particularly important within the sphere of work, in which more and more people work remotely. I can be working “with” people everywhere and their little personal things, as insignificant as they can be, can give me the feel of a virtual office (even, at times, a virtual cubicle!).

(3) Breaking news
– In certain sectors, including technology, getting the information while it is hot and being part of the “breaking wave” can give one new energy — a bit like surfing. If you are on the beach, it just isn’t going to be exciting for you or anyone else watching you. And, with each new wave, you can “surf” everywhere.

(4) Flattened world
- In many respects, I disagree with folks like Thomas Friedman that describe a flat world as a good thing — but in some instances it can be very good. These mediums often allow us to reach across barriers for causes good or bad — increasing the accountability of political figures and companies.

If there is a good, of course there is a bad. One needs to be aggressive in filtering information that might be useful and removing completely useless sources of information.

Here are some evaluations:

(1) Twitter -> Hit or miss. If I am plugged in all day I catch everything. If I unplug, I only get little bits. I wish I had a better filter.
(2) Facebook -> I aggressively “hide” people not in my immediate vicinity or with whom I am not working. I get value from finding about things from people/orgs I watch, as the signal to noise ratio remains reasonably high.
(3) Hacker News -> I created a filter for Hacker News since it was as bit like Twitter for me.
(4) RSS -> I have almost abandoned RSS.
(5) Email -> I have 50+ filters setup in Gmail and probably that number of folders and subfolders. This remains my primary “feed.” I actually think Facebook could replace this, largely because there are a lot of things missing in email protocols that they can build into Facebook messages (e.g. the “read” notification). This would be a huge win for Facebook, since although within messaging right now they are doing a good job with convenience, if they actually had a superior technology set they could make a good show of replacing email altogether (this was, in part, part of the goal of Google Wave).

If you are interested in more, here’s a related Hacker News thread.

P.S. It is clear that Salesforce, Yammer, etc. are following rather than leading the “Facebooks” of the world, so I don’t think it makes sense to focus on them in particular.

As many followers know, I was an excited early adopter of Cloudspokes, what I hoped would be an innovative new platform for engaging developers on interesting projects in different languages. Although I won bunch of prizes early on and even helped promote the platform, at a certain point I stopped participating in Cloudspokes. Since I am frequently asked questions about this, I thought I’d explain why publicly.

The simple premise of Cloudspokes is this:

(1) Company contacts Cloudspokes with a project and prize amounts (e.g. a javascript widget with a $1000 first prize and $500 second prize)
(2) Cloudspokes lists project
(3) Developers submit entries
(4) Reviewers award prizes based on how well entries meet specs

In a certain sense, this is part of a phenomenon known as “crowdsourcing” which has a fantastic appeal from the standpoint of many companies. Instead of paying someone in house to do the work (who likely cannot) or hiring a consultant (who will cost a lot), we use the old competitive instinct to get lots of people to submit work. We engage more people, get more work, and hopefully get a better result for less cost.

There are several immediate problems that present themselves. First, it must be noted that there are two sets of client-worker relations present here. The first is between the platform (Cloudspokes) and the company which has listed the project. The team responsible from the platform needs to convince the client that their developer base can deliver on projects in order to get the client to list their projects. The second is between Cloudspokes and the developers themselves. In a very real way (which the Cloudspokes team does not seem to have recognized) the developers are the real customers of the platform. For, while the company which listed the project is offering money for a project, there are certain safeguards which exist that prevent them from losing that money if nothing is delivered.

The same does not exist for the developer. The old adage is true: time is money. And since developers are exchanging valuable time for the chance at money, they must determine just how much that time is worth within the context of a Cloudspokes project.

Here are some examples from my experience that illustrate how Cloudspokes does not “put the customers first” when the customers are developers (I cannot comment on any of their other customers). First, I originally stopped participating in Cloudspokes contests after I never got a response from an entry of mine in approximately April of last year, which was a blueprint for testing the skills of Salesforce developers. After being irritated for several months, I contacted Cloudspokes via email and found out that they had some unpublicized scoring system, by which if they didn’t like any entries all that much, they wouldn’t pay anybody and they wouldn’t notify them either. This means, of course, that supposed “first prize” was never awarded to anyone. That, which to me constituted a severe breach of business ethics, was enough for me to discontinue working with Cloudspokes for several months.

However, thinking that some of the warts related to Cloudspokes might be related to the newness of the platform, approximately six months later I decided to give Cloudspokes another try. What I found was extremely disappointing. Many of the warts of the original platform (e.g. contradictory and confusing specs for challenges, lots of spam messages, the inability to type carriage returns in messages) continued to exist after ported to Ruby on Rails. For instance, the March madness challenge, which I attempted to participate in, had all of the following problems:

(1) The timer, which was supposed to measure the amount of time it took to complete the challenges, frequently reported times that were off by an order of magnitude.
(2) The questions, in which one was supposed to fix an error, frequently included multiple errors, including misspellings of method names, making it often impossible to determine which error one was supposed to fix.
(3) The results page at the end of the challenge did not display consistently.

Moreover, when people used the message board of the challenges to report these problems (the only place where one could) the response of the Cloudspokes team was to claim that the message board they were spamming the message boards — also claiming that the timer was being gamed instead of that it was, as later turned out, simply broken.

I also participated in another challenge that was simply terminated before the deadline without any notice posted on either the blog or page for the challenge. Although the Cloudspokes team later claimed that they would continue to score the challenges (despite the fact that the challenge was ended by the Cloudspokes team before the deadline), I believe they did not award any prizes whatsoever. During a long email chain, I was told that I could and should be able to to see the results of the challenge — however, when I reported, after several attempts to view them, that I could not, the Cloudspokes team simply stopped any attempt at “customer support” and no longer responded to my messages.

Given my limited experience, I suspect that there are probably of hundreds of improperly scored and terminated challenges in which developers are simply handed the short hand of the stick and left to lick their wounds when customer support stops responding. Also, although they have a new scoring mechanism supposedly issued by your “peers” (something I suspect is merely a marketing slogan), it appears to me primarily a way for them to avoid awarding any prize money, even if the original problem was that the challenge was impossible under the constraints, contained contradictory specs, or would have required far more time than feasible given the prize money awarded.

My own principle is the “golden law” of doing to others as one would wish to receive oneself. In this case, it includes not wasting the time of anyone, especially talented people who don’t have time to waste following up on your lack of customer support.

Consequently, given the amount of time that Cloudspokes has wasted even in attempting to help them fix things that should have been working before they released them, my provisional judgment is that talented developers should leave the platform to programmers without jobs or job prospects.

Personally, I prefer to do the best job possible and to get paid for doing so (when I’m not working on contributions to the wider open source ecosystem).

Also, although I’ve already given lots of generally ignored free advice to the Cloudspokes team, I’ll leave it with these:

(1) The customer includes the developer
(2) The customer should come first
(3) Don’t lowball people
(4) Don’t waste people’s time
(5) Fix gnawing bugs before releasing new features
(6) Wait until they work before you release things

That said, I hope that the platform is something I would consider using in another year.

Follow-up comments:

Since this was originally posted, Cloudspokes responded with some helpful statistics that may indicate that my repeated problems with the platform (at least as regarded canceled contests and forgotten scoring) were somewhat exceptional. I’d like to give them the benefit of the doubt and so will probably be back at Cloudspokes for further assessment within a shorter period of time than originally anticipated.

If, as I have suggested, to the maxim “real artists ship” should be added “real apps scale,” scalability is not merely a function of more users, but necessarily of a codebase larger than a single or pair of geniuses can create. This is why many of the great geniuses of history, among them Plato and Aristotle, worked within the context of schools, distributing the knowledge that they had achieved over a larger extent of time and space via human intermediaries (i.e. students), and these schools, of course, had teachers beyond the genius-founder.

Business is, if frequently following a different set of impulses than potentially “love of wisdom” and educational institutions which follow in their potentially altruistic path, is nonetheless subject to a similar set of limitations. One simply cannot know everything and, even if, in a fractal-mode, one can understand the basic principles of a subject at a high level of abstraction, this “higher-knowing” does not necessarily give one the skills to solve all problems that arise at the microscopic level of the day to day.

Programmer-mathmagicians have frequently attempted to solve this problem by simply residing in the highest possible level of abstraction, not withstanding that anything written, at least as attested in many philosophical schools, cannot represent reality at the most abstract way. In this sense, we soon reach the limitations even of an incredibly abstract language (i.e. Lisp), insofar as the implementation must contain a machine and it is no longer a truely and “purely” a lisp machine as soon as it contains assembler.

The fractal is a symbol, in a certain fashion, of the juncture not only of the sometimes invisible mathematical patterns which hide between and beyond virtually all of nature, but of the fascinating interjection of beauty which appears once we dive beyond that which is easily put into words.

In a sense, to recognize this trend in the 21st century we must have some historical awareness, at least in the sense in which historical awareness allows us to understand the categories in which we think as a product of our education at a particular moment in history. This allows us to realize that the modern emphasis on the defined self distances us from the “genius” of the supreme flow state which was exalted as “divine madness” in the early Greek philosophical tradition and similarly exclaimed in Indian and Chinese philosophical traditions.

However, supposing we have let the defined “self” go, even for a moment, how do we descend into the world of diverse and variegated languages? The challenge of Plato’s academy and every educational institution since was just that — we simply have to descend beyond our contemplation of beauty and into the dirt of the every day.

In an ancient Chinese conception, this was known as the fusion of heaven and earth, and heaven here was not simply a place but an active force which, once opened up to, could serve to illuminate divide the great expanses.

The polyglot challenge and accompanying fractal imagery, is then, potentially an opportunity to recognize the grand patterns that exist on a higher level of abstraction and, by recognizing the grand patterns (and beauty that accompanies them) to dive into the details with the “right tool for the right job,” a task that is otherwise quite difficult to realize.

The sad problem is that frequently the world remains divided between those who, in a particular place of abstraction, refuse to deal with the nitty-gritty details of the “blub” things of ordinary life, and those who, because of immersion in “the way things are done,” fail to see any better way.

This is particularly sad at a moment in time, like the present, where “the way things are done” simply is shown to be insufficient. If, to use a military metaphor, there is an enemy at the gates and yet the soldiers refuse to fight because because the plans are not well-defined, the stocks of food or weapons are insufficient, or because their commanders are idiots, we might understand this. We can even picture them retiring into the countryside because the countryside is a safe and comfortable place to be. However, no problems are solved this way.

However, this suggests that even if a military metaphor might be appropriate, the appropriate response is rarely “forward,” in the charge sounded by the exuberant officer, but rather up, in the sense that a contemplation of things in context of a higher level of abstraction (or in accordance with the Way or Dao of the great philosopher of war Sunzi), will produce more beneficial results than those who respond to instigation by either charges or retreat.

As for the polyglot future I have claimed in other posts to be excited by, I think it is gradually reaching increased definition. It demands, among other things, people who are willing to know things well at a level of an abstraction and be capable of knowing the details while admitting they do not know everything. This is to suggest that the developer-architect will be an increasingly important role as multiple platforms are engaged in increasing levels of abstraction.

However, it also demands that these same people are capable of engaging at the most detailed level and, with regards to this, I can only be excited for a a most “fractastical” future.

Here are a few things I’m excited about at the moment:

(1) Meteor. Recent explosive entry into the Javascript libraries/frameworks, which provides a “railsesque” framework for developing with a Node.js backend and presumably MongoDB datastore. Fills a huge need and appears to do just about everything just right, both in terms of design decisions and community engagement. I predict total domination.

(2) 12 Factor App. Not commented on heavily with the Salesforce community though a product not only of top-notch Heroku smarts but also with commentary from top Salesforce eggheads (e.g. Mountjoy), I think this is the sort of document we will be reviewing in five years as “prophetic.” In many ways, the future is already here, but it will take most of us a long time to realize it.

(3) jQuery. I know that there is nothing new here, but as a diehard jQuery enthusiast, I still think its time of triumph “in the enterprise” is coming soon as people finally get the message (and also realize that UI of their product is important).

(4) Berlin. Not quite Silicon Valley but people are picking up the torch and I expect to see more significant European-based challengers instead of just imitators over the next few years. Don’t doubt the Curry Wurst.

(5) Polyglot solutions. Even though it has often failed to invest substantially in its own open source ecosystem, Salesforce has taken something of a lead in acquiring in the fascinating although occasionally murky world of “polyglot” solutions, where various languages are used to provide what presumably is the “right tool for the job.” Despite the occasionally murkiness and gangs of cheerleaders without any real understanding of the strengths and weaknesses of various technology sets, I’m excited to see more definition about what constitutes the “right tool for the job” and robust composite solutions — of course, expect to see this more on the “bottom up” Heroku side than the typically top-down Salesforce side.

(6) Fractals. Okay, probably you know this already, but I think other people are finally starting to get the message about just how “fractal-eque” many parts of the world are.

I think there is an interesting set of motivations in the enterprise world, where most people are in it for the $$$ and it is difficult to see why you would contribute something for free, especially to people who will simply use it to add to their pile of cash. So, to those involved like me, why do you do it?

Seriously, I’d like to know as I’m doubting my own open source commitment at the moment. It is all well and good, but “freebies,” especially in the Salesforce world, don’t pay the bills.

Explanation:

Blogs: WordPress.com (1 owner, 2 contributor), WordPress.org (2 owner), Tumblr (1), Posterous (1), Blogger (3, all defunct). Also had several Ruby-powered blogs all gone.
Social Media: Twitter (1 business, 1 personal, 1 product, contribute to 2 others), Facebook (1 + 1 page), Google+ (1 + 1 page)
Hosts: Dreamhost (1), Yahoo (1), Linode VPS (1)
CMS: WordPress (2), Refinery CMS (1), Hardcoded HTML (1)
Discussion Boards: PhPBB (1), Invasion Power (1). Contribute to a few others.
Domains: Yahoo (9), Network Solutions (1), Dreamhost (1), Godaddy (1).

News Aggregators: Hacker News (2)

From top to bottom:

Blogs: No clear lesson from the blog world, only that at the moment it makes sense to have multiple blogs divided by topic. I have a company blog, a developer blog (this one), a “work” essay blog, a personal essay blog, and an art/inspiration-of-the-moment tumblog. Over time moved to feature-rich easily-maintainable hosted options from more custom options, don’t plan to go back. That said, I miss the nice syntax highlighting available not on WordPress.com, which is probably the major reason why I am planning to move this blog over to wordpress.org in the near future.

Social Media: Twitter, and particularly my “work” twitter account gets the most attention (I put it in quotes because my I don’t believe that work should ever be work, but rather fun and I try to keep things that way). My personal twitter gets barely any love. Facebook for me is now 60% liking things from the “work” world and 40% personal updates, which seems a bit odd. Google+ is an outlet for nerdy things that I don’t think will be appreciable to a more general audience.

Hosts: I’m a legacy customer of Yahoo from when they were great. I am very happy with Dreamhost but it is too much hassle to move all of my websites over there.

CMS: I’ve run virtually every CMS known to man at some point and at this point I actually don’t see any need for most sites for anything more complicated than WordPress. I just spent some time with two Ruby CMSes (Locomotive and Refinery) but would never recommend them to anyone who doesn’t want to spend a rather substantial amount of time tinkering in order to get it up and running for what is, in general, a less capable system (that said, you can extend it yourself, which is cool).

Discussion Boards: Was happy with PhpBB for a long time but at some point lost the time/interest to make all the modifications to optimize it. Been experimenting with other options (vBulletin/IPB) but haven’t had the time to pick one. Paying for IPB but not using it.

Domains: I’ve greatly reduced my number of parked domains, largely because I was all on Yahoo and they more than tripled their prices. Not too sure that this was the right decision, but absolutely hated Godaddy and it was too much of a pain to transfer domains. Still looking for a good, cheap host to park domains for future ideas if anyone has a suggestion. I like Network Solutions okay but they just spammed me with “.XXX” domain advertisements which I didn’t appreciate.

News Aggregator: 2011 was the year when I basically stopped reading all news not immediately relevant to what I was doing, perhaps because I find it a generally depressing waste of time (I used to read the Economist cover to cover and follow a bunch of other publications). The major winner here is Hacker News. I use two accounts, one for general posting and one for commenting on things which I expect will be controversial (Hacker News has a bunch of “karma police” that, in what I believe to be a generally laudable attempt to maintain high comment quality, frequently go overboard in downmodding non-mainstream viewpoints).

A page showing the jQuery elements compared with standard elements can be found here.

Usage

Complete specifications follow for each enhanced component:

Text:

<c:enhancedText pageController="{!this}" fieldName="Text__c"   />

You can also force there to be both a uppercase and lowercase letters by telling to to validate as a name:

<c:enhancedText pageController="{!this}" fieldName="Text__c"  validateAs="name" />

Email:

<c:enhancedText pageController="{!this}" fieldName="Email__c"  validateAs="email" />

Number (Double):

 <c:enhancedText pageController="{!this}" fieldName="Number__c" validateAs="number" />

Percent:

<c:enhancedText pageController="{!this}" fieldName="Percent__c" validateAs="percent" />

Checkbox (Boolean):

<c:enhancedCheckbox pageController="{!this}" fieldName="Checkbox__c"   />

Phone:

<c:enhancedText pageController="{!this}" fieldName="Phone__c"  validateAs="phone" />

Defaults to international phone, for US domestic phone use:

<c:enhancedText pageController="{!this}" fieldName="Phone__c"  validateAs="phoneus" />

<c:enhancedSelect fieldName="Picklist__c" pageController="{!this}" object="{!TestObject__c}" /

Multi-Picklist (Multiselect)

<c:enhancedMultiselect pageController="{!this}" fieldName="Picklist_Multi_Select__c" object="{!TestObject__c}"  /

Lookup (Reference) :

<c:enhancedLookup pageController="{!this}" fieldName="Test_Lookup_Object__c" objectToLookup="TestLookupObject__c" />

Lookup (Reference) :

<c:enhancedLookup pageController="{!this}" fieldName="Test_Lookup_Object__c" objectToLookup="TestLookupObject__c" />

Textarea :

<c:enhancedTextarea pageController="{!this}" fieldName="Text_Area__c" expandable="true" width="145" height="50" />

Controller:

(1) Install enhanced components via unmanaged package install link.

(2) Have your main controller (which can be a standard controller) extend PageControllerBase:

public with sharing class DemoPageController extends PageControllerBase

If you want to use a standard controller include this:

	  public DemoPageController(ApexPages.StandardController controller) {
	    	standardCon = controller;
	        this.myObject = controller.getRecord();
	  }

Then include this function:

	  // First we save the values from the Enhanced Component controllers, then whatever standard fields there are.
	  // If you are using standard fields in addition to enhanced components, whichever method is utilizing fields required by the API should always be in the first position

	 public PageReference save()
	 {
	  	ecSave();
	  	standardCon.save();

	  	return null;
	 }

Page:

Include your favorite jQuery UI theme easily:

    <apex:stylesheet value="{!URLFOR($Resource.JQueryUICup,'development-bundle/themes/cupertino/jquery.ui.all.css')}"/>

See how standard themes will look by choosing the switch theme option on this page. You can also easily create your own theme with Themeroller.

On your page you will also need to enable validation.

The easiest way is to assign a form styleClass element to your form declaration:

<apex:form styleClass="form" >

Then just before you close your form tag add an action function:

       <apex:actionFunction action="{!pageController.save}" name="saveMe"></apex:actionFunction>
  </apex:form>

Then add the automatically generated javascript:

    <apex:outputText escape="false" value="{!pageController.completeJavascript}"/>

This line will not only add hotlinks to the Google and Microsoft CDNs (for JQuery, JQueryUI and JQuery validation plugin), it will enable validation any form with a form class and add all of the necessary methods for validation.

If you don’t want to use the automagic client-side validation, hotlink the necessary CDNs manually:

    <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"/>
    <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jqueryui/1.8.1/jquery-ui.min.js"/>

Here is a list of all of the Plugins currently included:

JQuery UI 1.8
JQuery Validation (Joern Zaefferer)
Autocomplete 1.1.1 (Joern Zaefferer)
Expandable 1.0 (Brandon Aaron)
Select Menu (Filament Group)
Multiselect 0.6 (Eric Hynds)

Github repo here.

Step one: Create your rails app.

 rails new ninjaspeed 

Step two: Add the database.com and helper gem to your GEMFILE (this will be in the ninjaspeed directory)

 gem 'databasedotcom'
 gem 'databasedotcom-rails' 

Also add the postgres gem (you aren’t using the db on Heroku but need it anyways) and a gem to handle precompiled javascript (for the JQuery Mobile):

 gem 'pg'
gem 'therubyracer'
 

Step three: Install the new gems

sudo bundle install

Step four: Add scaffolding for a new resource that corresponds to a resource in Salesforce

 rails generate scaffold_controller Lead FirstName:String LastName:String Company:String 

Add an entry in your routes.rb file

 resources :leads

Rails is straight up MVC, and you just created a controller and a view. Check out your app/controllers and app/views folders to see them. Salesforce/Database.com will be your Model.

Step five: Deploy this baby to Heroku

 
git init 
git add .
git commit -m "i love databasedotcom"
heroku create
git push heroku master
heroku addons add:piggyback_ssl

Step six: Take the new funky fantastic name you got and enable remote access in Salesforce

Login to salesforce. Go to Setup -> Develop -> Remote Access -> New 

Enter the address of your app (e.g. https://stormin'-samurai-558.herokuapp.com)

You will get a client key (this is also the client_id) and your client secret 

Step seven: Add your salesforce credentials to a file in the config folder called databasedotcom.yml

 
databasedotcom.yml
####
client_id: 3MVG.....
client_secret: 1323224123...
username: mysalesforceusername@login.com
password: passwordPlusSecToken
host: login.salesforce.com <-- use test.salesforcecom if using a sandbox
debugging: true

Add this to your app/controllers/leads_controller

 
LeadsController < ApplicationController
  include Databasedotcom::Rails::Controller

In the same file you need to add a few more required fields. Navigate to the create method and add three lines:

 
  def create
    @lead = Lead.new(params[:lead])

    # ADD ME
    @lead['OwnerId'] = '005U0000000IekIIAS'    <-- ownerId here is the Id of the User you want the Lead associated with
    @lead['IsConverted'] = false
    @lead['IsUnreadByOwner'] = true
    # END

Thanks to some backend magic, the databasedotcom-rails gem automatically initializes the client you need to connect to salesforce so you don’t have to worry about it.

Step eight: Add in a jQuery mobile stylesheet so this doesn’t look super ghetto (optional)
Navigate to app/views/layouts/application.html.erb and edit these lines to the header:

<link rel="stylesheet" href="http://code.jquery.com/mobile/1.0/jquery.mobile-1.0.min.css" />
<script src="http://code.jquery.com/jquery-1.6.4.min.js"></script>
<script src="http://code.jquery.com/mobile/1.0/jquery.mobile-1.0.min.js"></script>

Put the yield tag in the body in a div like so:

<div data-role="page">
   <%= yield %>  
</div>

For your apps/views/leads/new.html.erb, divide into a couple of sections

<div data-role="header">
   Lead form
</div>
<div data-role="content">
   <%= render 'form' %>
</div>
<div data-role="footer">
   If you want it
</div>

Navigate to config/environments/production.rb, find the config.assets.compile, and set it to true (turn on the live compiliation of assets)

  config.assets.compile = true

Step nine: Remove extra stuff from your _form.html.erb/strong

This is all you need:

<%= form_for(@lead) do |f| %>

  <div class="field">
    <%= f.label :FirstName %><br />
    <%= f.text_field :FirstName %>
  </div>
  <div class="field">
    <%= f.label :LastName %><br />
    <%= f.text_field :LastName %>
  </div>
  <div class="field">
    <%= f.label :Company %><br />
    <%= f.text_field :Company %>
  </div>
  <div class="actions">
    <%= f.submit %>
  </div>
<% end %>

Step ten: Deploy to Heroku

git add .
git commit -m "I love databasedotcom even more now"
git push heroku master

Navigate to yourapp.heroku.com/lead/new, and presto-chango, a mobile-enabled submission form that hooks up to Salesforce.

You can also view leads in the system by navigating to yourapp.heroku.com/leads

Also, if you want to add in validation (and I suggest it) you can do this client-side rather than serverside.

Oh, and in case you were wondering the source code for all this is available on Github.

]]>