Why Responsive Design are Best for Mobile Devices?

Responsive design is quite popular these days. It is a new and revolutionary way of planning to develop websites which will be compatible for both PC, and laptop users as well as for the latest generation of tablet and mobile users. Right now it is recommended either to develop separate sites dedicated to the mobiles or tabletswith separate web addresses or use a device that will detect the target devices and redirect the users to the device specific site. But there are two unique issues related to these suggestions.

  1. The device identification script that will be used to identify the mobile devices can face problem in tracking the huge number of mobile devices are continuously hitting the market every other day.
  2. Developing and maintaining so many numbers tablet and mobile specific sites may take lots of time and can be lot more expensive than the normal.

Responsive design facilitates with a comparatively better solution for the disintegration of the web devices. The most important target is to create a chain ofscalable designs intended towards the particular group of devices by utilizing scaling images and flexible grids. Web browsers offer data on the maximum number of pixel width that they support with the help of a CSS element that is termed as a media query. This value helps us to assume about the target devices as the maximum size of the width will be nearly the size of the screen of the device.

Instead of developing different websites with different contents, separate interfaces or creative elements, it is better to develop a responsive site that will adjust and scale the layers, which are for presentation, to offer the best feel within the screen space available.


Many think that responsive design should be taken into account for every new website designing project. Though this may not be possible for all projects because of the factors such as budget, time, technical expertise and target audience. But at least it should be discussed while planning for web designing.

Media Query

Breakpoint is said to be the media query value which mark the switching of a new type of device. Mainly fluid designs are created to fit it within the preset limit of the media query. These limits will be equated to various types of devices like laptop, desktop, tablet and smart phone.

Once this threshold of the breaking point is crossed, another set of CSS codes will get activated to create the webpage with the help of perfect fluid layout, images and text format, navigation design targeting to these devices. There is no set of breakpoints that is universal as the idea of responsive design is quite new to the industry till date.

Once the media query range and breakpoints are fixed now it is the time to fix the width of the design. Though the designs are developed to fit within the ranges of the media query still a starting point is necessary to be there. It is probably the simplest to set the lower end value of the media query range for the width of the content and later fit the layout upward if necessary. But there is an exception in the mobile portrait design where the value is set at 310 representing the commonest minimum width used for smartphones. In this case, the design needs to be fitted both upwards and downwards as per the requirement.

Food Sense

It can be considered as the convenient option for the most number of projects related to responsive designing. Two options for mobile designing can be merged together to get two completely new and separate designs offering far better results. There is an extra benefit i. e. you can add breakpoints later if you wish to adjust extra-large screens without designing the site all over again.

There is certain misconception related to the responsive design that, it is only developed for web browser on mobile. It is all about designing websites for a particular screen size. Both developers as well as designers need to change their thinking about web designing. There are many designers who come from graphic designing background and are familiar with working in limited width mediums likebillboards, ads, fliers and many more.

But while designing responsive sites the designers must have an idea on how the sites will look on different widths to make the responsive site the best one. They also think about the way the navigation should be adjusted. Moreover, the designers should realize that they will not be able to control the design anymore and have to adopt new flexibility. If the responsive design turns out to be a successful one then it is possible to develop wonderful sites with huge usage in all devices.

Spigot Design

Responsive Web Design and CMS

Responsive design is a new concept which is growing rapidly all over the world. But still its compatibility with content management systems and other platform is uncertain. Most of the discussions related to responsive web design come from the front end development point of view. However, the large number of websites are created with strong back end CMS. There are few content management systems which allow better grip over the presentation layers than the others.

Therefore, the expense and the amount of effort for moving to responsive design may differ. Companies having strong technical expertise should evaluate the way using which they can align well with the responsive design plan and at the same time should define the upgrades as well as the other changes that are needed to be done.

Like many other new technologies responsive design is also not free from few drawbacks. Internet Explorer 6 and 7 do not support some features that are used in an ideal responsive design. But that does not mean that the design will not be visible in comparatively older browsers. The design may function or look a bit different than the way it is looked in the newer browsers unless you add some extra codes particularly for those browsers. It is suggested that before you start designing you should take a look at the web analytics data to check the percentage of your target audience depends on the older browsers.

Clean Air Commute Challenge

The technique of using only the most popular screen size as reference may become backdated with the modernization of the devices. The new way of responsive designing which is emphasizing more on content, rather than on context is getting introduced to the market. But this is yet to be standardized.

Media queries that is used downloads all the contents even if you do not see them on screen. This reduces the download speed of responsive websites comparing to the device designed sites.

You should always opt for a site that is compatible with all kinds of devices. If you already have a site then it might be difficult or expensive to make it adapted to the responsive design. Therefore, it will be easier to use mobile website template which is a convenient and an easy way of adapting conventional websites for mobiles and other devices.


Source: Why Responsive Design are Best for Mobile Devices BLOG

Author: Angelina Jennifer

Referenced site: http://designmodo.com/why-responsive-design/

Challenges and Opportunities in Mobile Application Development and Mobile DSLs

The world is turning mobile, it would be hard to argue otherwise with over two hundred millions smartphones, tablets and airbooks already sold worldwide. This evolution introduces significant changes to the form factor of software solutions (Table 1) that mandate carefully vetting prior to initiating the development of a mobile solution.

Overall, mobile users generally pay more attention to the user experience (UX), and when they have a choice they prefer a native look and feel be it for email, social networking, checking weather, sport events … even Google is building native apps. Increasingly, developers can emulate a native experience in the browser thanks to the progress made by WebKit.

If these changes can already significantly impact a mobile solution delivery process, the most profound architectural change introduced by mobility is the evolution from “connected” applications to “converged” applications where voice, messaging, location services, data services and video may all contribute to deliver an experience simply unavailable to a desktop or a Web application. In the early 2000s, in the wake of SOA, several companies had developed the concept of Composite Applications or Connected Systems. Mobile applications advance this concept to the next level and enable an arbitrary application to consume a mashup of any number of voice, messaging, data, location and video services maintained by different 3rd parties which each may have a direct relationship with the end user, independent of the application. Converged Apps create strong privacy constraints (as the application is granted access to contacts, location, movies, TV programs …). Standards like OAuth 2.0 have emerged to support these scenarios. Oauth 2.0 requires the developer to maintain individual API keys and (user) access tokens for each type of services. Developers can no longer rely on a “single sign on” mechanism such as OpenID or LiveID because they share the identity of the subscriber with the application and do not provide any authorization capability. Converged Applications are also often requested to perform in a downgraded mode when the user does not grant the application full consent to consume all the services on his or her behalf.

Form Factor End-User

End-users carry their client with them Users no longer need to access the same application on a number of computers (home, work, friends...). They want the best experience for each form factor. Need to support multiple experiences for each type of mobile client, in a cross platform way, which can be even more challenging than cross browser support
Power/Bandwidth Battery life/Bandwidth becomes a major UX element Need to develop software with least power/ bandwidth consumption
Screen size Seeking optimized UX on such a small screen Need to forget all current UX design rules and reinvent them for mobility
Sensors Expect apps take advantage of all on board sensors (camera, motion detectors, …) that can help buildvery smart applications Need to master specialized libraries and adapt their apps to device capabilities
Voice and Notifications Expect seamless integration between apps and voice and messaging, including speech processing Create compelling user experience and integrate notifications in application workflow
Near-field communication Help the user bootstrap sophisticated processes which are based on user identity (payments, local app download…) Complex back-end integration to securely share user data and manage transactions


Table 1. The Impact of Mobility on End-Users and Developers

There is another major change that can be easily overlooked, even dismissed: Mobility has revolutionized both monetization and software distribution strategies from a simple “ring tone” business model. We encourage you to pause for a moment and really focus on the impact on having the ability to reach hundreds of millions of customers, at any time, simply by uploading your app to a few App Stores. For us, this means that a developer has many more opportunities to create apps dedicated to specific market segments and on top of that seasonal features: a successful solution (think Angry Birds) need not only to be released for many types of devices, across several major platforms, but for each of these, we could offer several apps targeted at different market segments, each requiring continuous releases of new features during the course of a year. The bottom line is that, if you plan to be really successful at building a mobile solution you have to be ready to deliver a family of apps, not just “one app” like in the Web or Desktop era. The seasonal aspect and the relative high degree of competition between apps puts even more pressure on the development cycles, and requires that developers release new features often, especially when you factor in Ads and “in-app” payments business models.

Last but not least, by any measure, this new distribution model allows successful mobile applications to grow to reach tens of millions of users, in a short time frame, creating a scalability nightmare and the need to constantly re-architect the back-end ahead of the growth of the user base.

With such short development cycles, this rapidly changing, fragmented and technologically complex new frontier is set for the perfect storm: are Mobile Developers getting ready to face these challenges? Even though the functional scope of mobile applications looks small, the need for back-end development and integration, support for multiple platforms, security standards and optimized UX could potentially drag projects to a black hole and miss both the time and cost windows of a large number of potentially great applications.

And our list is far from exhaustive! The bottom line, is that attempting to build mobile applications with software paradigms, tools and processes that were developed for Desktop, Client/Server or even Web-based Application architectures is pretty much a guaranty of not taking advantage from all that mobility has to offer because no-one and no technology is ready to develop multiple variants of the same applications.

In this article we propose to review the broad choices facing developers in terms of mobile app technologies, tools and development in the light of the form factor of Mobile Solutions and offer a path forward to develop the engineering approach to a practice, which for the most part remains today a complex craft and cannot scale as is to build successful mobile solutions.

The arguments developed in this article do not always apply to “mobile gaming”. Our focus is rather a large class of productivity applications, which could be referred to as “data, and process centric mobile applications.”

The Technologies of Mobile Applications

There are roughly 4 major categories of technologies:

  • Web–based (HTML5/CSS3/JS) and related Frameworks (JQuery, Sencha, …)
  • Native platforms (iOS, Android, Windows Mobile 7…)
  • Hybrid WebKit/Native
  • Proprietary middleware and clients (Red Foundry,…)

In addition, there are two approaches to facilitate the development of cross platform mobile applications:

  • Thin Native Clients which provide access to native APIs and / or render Web-based applications with a native look and feel (PhoneGap, AppMobi, AppCelerator…)
  • Domain Specific Language from which native or Web-based code is generated (Applause, Mobl, Canappi…)

In this article we will not address the proprietary middleware platforms. The mobile app space is evolving so rapidly that likely many of these platforms will disappear or specialize on a given niche that they can execute particularly well (e.g. mobile magazines)

On of the key advantage of Web-based technologies is their rapid and continuous deployment model that circumvents the processes of App Stores. Many developers see this as a huge benefit to the overbearing control of vendors like Apple, and now Amazon. Some view Web technologies as the open door to phishing and fraud as attackers take advantage of young browsers and thin native clients built by startups without enough security hardening experience. By contrast, the incentive for an attacker to take control of a single native application is much lower in terms of potential user base and benefits.

Beyond that, Mobile Web based solutions will suffer from the same issues as their desktop counterparts in terms of browser incompatibilities, latency, UX, an uncertain monetization strategy, not to mention the slow evolution of Web standards. We are not arguing that there is no future market for the mobile Web apps, after all, mobile Web apps are proliferating, however it certainly mandates careful selection of technology and understanding its advantages and limitations in the context of User Experience and the value that App Stores bring to the end-users and a small development team.

Apps developed in native technologies outpace the alternatives both in the number of apps and the % of time spent by the users on their mobile device(s). Ironically, however, these so called “native” technologies mostly evolved from decades old proprietary desktop technologies and tools. For instance, the iPhone SDK is principally coming from a technology that was developed in the late 80s, a time when Garbage Collection was still a service provided by municipalities. If Google has gone the extra mile of re-inventing a programming model dedicated to mobile applications with concepts such as activities, intent, services, content providers… it’s Android SDK feels like a decade old Swing SDK and its declarative UI architecture and the way it connects to the Java implementation, via the “R” class, makes Windows 95 GUI programming model visionary.

Consequently this lineage makes, “native” technologies unnecessarily complex and overwhelmingly diverging because their programming model was rarely built from the ground up to simplify mobile solution construction, this means that for most companies, it is cost prohibitive to scale a development team and a set of processes with such cross-platform skills. Furthermore, none of these environments really take into account the predominance of “Converged Applications” (which didn’t exist a decade ago), offering no easy path to build and integrate with rich back-end APIs. Not a day of our working in the mobile app space seems to go by without hearing another story of an entrepreneur who has spent 12-18 months and has nothing to show for their efforts, simply because developing a native application for both the iPhone and Android devices is way too complex and requires advanced development skills. Whether Apple, Google and Microsoft (and Nokia and RIM) like it or not, this is not sustainable and eventually there is only a very small fraction of the companies that develop mobile applications that will use their native SDK directly.

This is why a number of cross-platform solutions have appeared on the market (PhoneGap,AppCeleratorAppMobi…). Most of them are based on rendering a Web-based app through a thin native client, taking advantage of any device native APIs. This presents multiple advantages in terms of development and deployment, but most quickly come to the realization that developing mobile applications in JavaScript is quite an adventure often perilous (thispresentation from Doug Crockford is a must-see for anyone looking to start a project in JavaScript), specially when some of these companies tout the advantage of “keeping the <body> tag empty”. This means that all HTML elements are entirely coded inside JavaScript elements while some parts of your UI are dynamically served by server components. These frameworks (and the HTML5 programming model) is also limited to the client code only as opposed to an entire stack from database, to the service layer to the client implementation. When selecting an HTML5-based technology it is important to pay attention to the Converged App  and the ability to mashup authorized API calls.

There is also a small number of companies which have developed Domain Specific Languages from which one can generate native code (Applause from Itemis, Canappi from Convergence Modeling). This generated code can be changed, compiled and deployed as if the application was written natively from scratch. The major advantage of this approach is rapid development cycles due to the simplification of the programming model achieved with a DSL targeted at mobile solutions, and a lower barrier of entry in terms of skills.

For instance, tables, in Objective-C, offer a large spectrum of capabilities but not without the introduction of great complexity making it hard for developers to implement a base line of expected behavior quickly. A DSL like Applause or Canappi’s mdsl in contrast captures succinctly a simple description of the table the developer wishes to render:

A simple layout description in mdsl (Canappi mobile DSL) representing a table of assignments

This simple mdsl snippet already generates quite a complex set of code for the layout view-controller (an mdsl layout is a re-usable set of controls displayed in one or more views, it is also the unit of binding to data APIs).

Now, if you want the table to refresh properly when the rows are added or deleted in a different view, you must make sure that the application delegate acts as a navigation controller delegate and implements “willShowViewController” method that ensures that the view is refreshed when some of its data has changed:

Objective-C Code Generated by Canappi for the Handling UITableView refresh

If you don’t implement that delegate method, the iPhone SDK has no other reliable way to ensure that a view is refreshed when some of its content has changed.

This is just one of the hundreds of tricks you need to get right for your mobile application to behave as expected, not to mention the lack of some key controls like radio-buttons and checkboxes, or the poor UX of important controls such as the picker or date picker and a “personalized” garbage collection mechanism.

DSLs can offer a much simpler programming model compared to native or Web-based programming models on the client side, however, their overwhelming competitive advantage is the fact one can generate the entire stack of the mobile solution from database schema, to the service layer to the client implementation ready to consume these services. For instance, from an entity descriptor, Canappi generates the MySQL schema and the PHP services, which, in turn, can be invoked readily by the mobile client.

Assignment Entity Definition and Corresponding PHP Code Generated by Canappi

This capability alone offer a general path to re-factor the code as needed when the user base grows or better server-side technologies appear on the market. OAuth for instance is a key technology for Mobile Applications, that is still under standardization and will probably continue to evolve significantly over the next two years. Why would a developer really care or its solution be impacted each time a new OAuth specification is released?

Development Tools

As one could expect there is a plethora of development tools that developers would need to know inside out to support an efficient mobile application factory.

The solution delivery process generally starts with mockup or graphical designer tools. One can use, for instance, Balsamiq as a simple wireframing tool that offers a series of controls dedicated to mobile applications. You may also want to use native graphical UI designer tools such as Apple’s Interface Builder (which is still one of the best GUI designer even though it was first built in the late 80s by Jean-Marie Hullot).

As part of the solution, you may also select a number of specialized libraries (for instance, bar code scannersgraphsmaps…) that are not necessarily integrated with the native development environment.

You will also need to use a variety of development environments, each with a very different programming model, not to mention testing frameworks.

Last but not least, your development team will also need to be versed in implementing and/or consuming Web APIs.

An Example of the Technologies a Typical Mobile Development Team Should Master

All these tools and technologies are completely incompatible. There is no way, one would use Interface Builder to create an Android screen, or get an iPhone application directly from a Balsamiq.

When using a DSL (where the “domain” is (Data centric) Mobile Solutions), the DSL itself can act as a “development hub” that supports the transformation of metadata over the entire domain and reduces the many-to-many transformations that would be needed to a many-to-one, one-to-many.

Canappi, for instance has successfully created an integration between most the tools and technologies shown in the figure above. One can take a XIB file (Interface Builder) and generate an RMFL file to rapidly iterate with key stakeholders who can see the application on their phone real time. The same mdsl file generated from a XIB file can also be used to create Android Resource files. Of course the tradeoff is that a DSL based approach assumes a specific programming model and type of mobile solutions. It will never deliver all the nuances that a raw native environment will ever deliver. The integration is also often one way though we are working on bi-directional integration wherever possible.

A DSL can also integrate some key libraries very easily. For instance mdsl integrates a graph library:

Graph descriptor of the Smart Inhaler Application

This simple graph descriptor generates well over 150 lines of code of the Core Plot library, a well designed graph library but quite challenging, even to senior developers. With Canappi, we were able to build an iPhone prototype, including the communication with existing WCF services, for the Smart Inhaler in less than a day, with 175 lines of mdsl and deployed on the App Store within a month by a developer who had never previously touched a Mac. This kind of result is rarely achieved, if not unheard of, without a DSL-based approach.

Invoking Web APIs is an essential part of any mobile project. Such code and the binding of the data to the UI is tedious, boiler plate and adds little value to the whole. DSLs can help here too by creating a simple description of the web services that then can be used to bind the corresponding results to different elements of the UI:

Web Service Descriptors for Facebook Graph API, Twitter and YouTube

Because DSLs can act as a development hub that integrates the best mobile tools from design to deployment, both on the front-end and the back-end, they offer bring a much higher level of efficiency when compared to any other technology (Native, Web or Web-to-Native). This means that the core of a solution can be built much more rapidly with a DSL, on all platforms, even if in the end some native code is added to the generated code.

They also offer the best path to create the opportunity to re-factor the code of a solution when technologies need to change with a minimal impact on the solution itself because there is a clear delineation between the DSL is not tied in any way to the library API. A DSL is at a much higher level of abstraction than the typical abstractions developers create to isolate their code from the usage of a particular library.

Mobile Development Processes

This complex architecture and technology environment is in sharp contrast with the very rapid development cycles and the many versions of an application that are needed to take advantage of the new monetization and software distribution channels. Developers are faced with both opportunity and the challenge to create several major releases per year, and possibly seasonal variants of the same application.

It would quite hard to design development and operational processes that sustain this agility without a DSL-based approach. Their programming model is very compact, and yields code than runs on all platforms and all device types. But, since the DSL programming model is so compact and complete solutions can be built with a few hundred line of code, this approach give you the ability to develop and maintain many variants of the solution, even if that means for each a slightly different (DSL) code base.

DSLs can also help to create an optimized User Experience as it enables the delivery team to rapidly create many more prototypes compared to a hand coded approach. Having the ability to create 10 different UX proposals and/or iterations that real users can interact with can make a big difference in the end product UX.

That being said, we would not want to give the impression that everything is perfect, when using a DSL. There is often the question of “Round Tripping” from the generated code to the model and back when the generated code has been changed. There are a couple of strategies that can make that part of the process flow more smoothly: source control systems can be used diff and merge new versions of the generated code with previous versions that have been modified. One can also programmatically isolate the changes in separate classes, called by the generated code. That way, only a small number of classes need to be merged and the merges are fairly straightforward.

Mockup-to-DSL-to-Native Development Process

The technologies that you choose in your mobile application factory will pretty much command the delivery process of your mobile solutions. It is critical that you design these processes accordingly and prepare for a level of agility hardly seen before.


Source: Challenges and Opportunities in Mobile Application Development and Mobile DSLs BLOG

Author's: Jean-Jacques Dubray & Kurt Schmidt

Referenced site: http://www.infoq.com/articles/mobile-dsl

How Online Publishers Can Take Advantage of Automation in Email


Email automation has the potential to help publishers—whether traditional, new, media and entertainment, gaming, or apps publishers—drive more Web traffic and encourage readers to visit their sites.

Yet, although publishers are creative producers of content, many are not taking full advantage of the potential that email offers to serve up that content. Automated email campaigns can help them reach the right audience at well-timed moments to drive more Web traffic.



Here are three ways that publishers can and should automate to retain and increase readership and site visitors:

  1. A welcome email or welcome series
  2. A weekly newsletter
  3. Re-engagement campaigns

1. Welcome Email or Welcome Series

Virtually all publishers have some sort of welcome email. However, most are generic and not always helpful for on-boarding your new subscriber.

Automation can help to improve your welcome email or email series and drive more engagement in several ways, including the following:

  • Triggered messaging: As a best-practice, the first welcome message should be automated triggered messaging, allowing you to send a real-time message to each new subscriber. Many companies will bundle welcome messages and send them all at one time each day. However, by using triggered messaging, you can continue to engage with your readers when you know they are engaging with you—right after they visited your website.
  • Audience segmentation: If you have collected information from a preference center during the registration process, use that information to personalize your welcome messages so that they are more targeted. Doing so will allow you to set a precedent with your new subscriber that future messages are going to be of interest to them.
  • Waterfall mailings: If your company has a wide variety of services, products, or offerings, you may want to consider upgrading from a single welcome email to a welcome program. By sending a series of emails, each focused on one topic or theme, you can better demonstrate your full offerings. The welcome series can be automated using a waterfall mailing, which sends out targeted emails that respond to a decision tree based on customers' interactions.

2. Weekly Automated Newsletters

Many publishers today are still manually creating their weekly newsletters. By automating newsletter creation, marketers will have more time for reporting, analysis, and improvements to their existing email program. Plus, automation can allow for customized content:

  • Automated assembly: Automate the creation of your newsletters with tools that allow you to automatically pull content from websites into your newsletters. The automation process will retrieve the content at the time of message assembly and immediately execute the email.
  • Personalized content: Publishers should also be using tools that allow them to personalize subscribers' content based on preferences they have chosen or on Web browsing behavior. Automated tools can dynamically populate content for the reader and deliver a custom newsletter for each subscriber.
  • Audience segmentation: If you email program is still in its infancy stage, at a minimum you should use audience segmentation tools to send different messages to different audiences. The data and knowledge that you will gain from this manual segmentation will prove extremely useful when you are ready to automate your newsletters.

3. Re-Engagement Campaigns

Regardless of how customized, personalized, or targeted your emails are, sometimes subscribers will stop engaging with your emails. How can you get those subscribers active and engaged again?

If you have not done so yet, create an email program that's specifically designed to engage with your inactive email subscribers:

  • Establish business rules: Using the targeting features in your email system, establish a business rule that executes an email on a daily basis to subscribers who have not opened or clicked on your emails in a certain number of days. Ideally, this program should be automated, requiring a low level of ongoing effort and maintenance.
  • Offer incentives: Give your subscribers reasons to want to become engaged once again. State any upcoming deals or specials you may be having. You can also include a discount or offer to entice them to re-engage with you immediately. If your brand has anything you can give away in the form of a raffle or sweepstakes, use those as well. For publishers, consider asking for updates to your subscriber's profile or ask the subscriber to participate in a survey.
  • Additional reasons to implement re-engagement programs: Each ISP uses different filtering technology to determine a message's inbox eligibility, and although they do not provide specific details about their technology, ISPs do monitor how often their users are engaging with your brand's emails. When a user has not opened or clicked your brand's emails for an extended period of time, you run the risk of your emails' being directed to bulk folders or marked as spam.

Virtually every publisher has the same need: drive more people to your online content. Automation helps publishers do so by delivering their messaging efficiently, to the right audience, with personalized content. The result will be to drive higher engagement in the form of more email opens, more email clicks, and more visits to your website—ultimately driving a higher ROI for your entire program.

Source: How Online Publishers Can Take Advantage of Automation in Email

Author:  Tony D'Anna

Referenced site: http://www.marketingprofs.com/articles/2015/27247/how-online-publishers-can-take-advantage-of-automation-in-email/

Four Ways To Build A Mobile Application, Part 1: Native iOS

The mobile application development landscape is filled with many ways to build a mobile app. Among the most popular are:

  • native iOS,
  • native Android,
  • PhoneGap,
  • Appcelerator Titanium.

This article marks the start of a series of four articles covering the technologies above. The series will provide an overview of how to build a simple mobile application using each of these four approaches. Because few developers have had the opportunity to develop for mobile using a variety of tools, this series is intended to broaden your scope.

Hopefully, armed with this knowledge, you will be in a better position to choose the right development tools for your mobile application’s needs. In this first article in the series, we’ll start with some background and then dig into iOS.

I’ve built the same simple application with each technology to demonstrate the basic concepts of development and the differences between the platforms and development tools. The purpose of this series is not to convert you to a particular technology, but rather to provide some insight into how applications are created with these various tools, highlighting some of the common terms and concepts in each environment.

FasTip is a simple application to calculate tips. Because this is a simple example, it uses the standard UI controls of each platform:


The screenshots above show the application running as native iOS, PhoneGap andnative Android applications. Appcelerator Titanium uses native controls, so it looks the same as the native iOS and Android applications. Our application has two screens: a main screen where the tips are calculated, and a settings screen that enables the user to set a tip percentage. To keep things simple and straightforward, we’ll use the default styles of each environment.


The source code for each app is available on GitHub.

Native iOS Development

Most applications in Apple’s App Store are written in the Objective-C programming language, and developers typically use Xcode to develop their applications.




To build an iOS app, you must use Mac OS X; other operating systems are not supported. The development tools that you’ll need, iOS 7 SDK and Xcode 5, are free of charge, and you can run the app that you build in the iOS simulator, which is part of the iOS SDK. To run your app on a real device and make it available in Apple’s App Store, you must pay $99 per year.



Once you have installed Xcode, you’ll want to create a new project. Choose “Create a new Xcode project” from the welcome screen or via File → New Project in the menu.


For a simple application such as this one, “Single View” is appropriate. Upon clicking “Next,” you will be presented with a dialog to enter some basic information about your application:


The value that you enter in the “Class Prefix” option tells Xcode to attach that unique prefix to every class that you generate with Xcode. Because Objective-C does not support “namespacing,” as found in Java, attaching a unique prefix to your classes will avoid naming conflicts. The “Devices” setting lets you restrict your application to run only on an iPhone or an iPad; the “universal” option will enable the application to run on both.


The screen functionality of iOS applications is grouped into what are known as view controllers. Our application will have two view controllers: one for the main screen and one for the settings screen. A view controller contains the logic needed to interact with the controls on a screen. It also interacts with another component called the navigation controller, which in turn provides the mechanism for moving between view controllers. A navigation controller provides the navigation bar, which appears at the top of each screen. The view controllers are pushed onto a stack of views that are managed by the navigation controller as the user moves from screen to screen.


Starting with iOS 5, Xcode has had storyboards, which enable developers to quickly lay out a series of view controllers and define the content for each. Here’s our sample application in a storyboard:


The container on the left represents the navigation controller, which enables the user to move from screen to screen. The two objects on the right represent the two screens, or view controllers, that make up our app. The arrow leading from the main screen to the settings screen is referred to as a segue, and it indicates the transition from screen to screen. A new segue is created by selecting the button in the originating view and then, while the Control key is pressed, dragging the mouse to the destination view controller. Apple’s documentation provides more detail about this process.


In the example above, we can see that a text field has been selected, and the property panel is used to adjust the various attributes of the controls. When this application was created, the “universal” app option was selected, enabling the app to run on both an iPhone and iPad. As a result, two versions of the storyboard file have been created. When the app is running on an iPhone or iPod Touch, the _iPhone version of the file will be used, and the _iPad version will be used for iPads. This allows a different layout to be used for the iPad’s larger display. The view controller will automatically load the appropriate layout. Keep in mind that if your storyboards expose different sets of controls for the iPad and the iPhone, then you must account for this in the code for your view controller.

In addition to directly positioning items at particular coordinates on the screen, you can also use the Auto Layout system that was introduced in iOS 6. This enables you to define constraints in the relationships between controls in the view. The storyboard editor enables you to create and edit these constraints.


The constraints can also be manipulated programmatically. The Auto Layout mechanism is quite sophisticated and a bit daunting to use at first. Apple has an extensive guide on Auto Layout in its documentation.

Associating Storyboards With Your Code

To access the storyboard objects from the code, you must define the relationships between them. Connecting items from the storyboard to your code via Xcode is not obvious if you’re used to other development environments. Before you can do this, you must first create a view controller to hold these associations. This can be done with the following steps:

  1. Choose File → New File.
  2. In the dialog that appears, choose “Objective-C class”:


3. In the next dialog, give your class a name and ensure that it inherits fromUIViewController:


4. Upon clicking “Next,” you’ll be asked to confirm where in the project the file should be saved. For a simple project, picking the main directory of the app is fine.

5. Upon clicking “Next,” you’ll see that a new set of files has been created for your view controller. Now, associate that newly created view controller with the view controller in your storyboard.

6. With the storyboard open, click on the view controller. In the “Identity Inspector” panel, pick the “Class” that this view controller is to be associated with:


7. Once this process is completed, the code for your view controller will be properly referenced by the storyboard entry.

To reference the controls that you’ve dragged onto a storyboard from your Objective-C code, you’ll need to define these relationships. The storyboard editor has an “assistant editor” view to help with this. Basically, it’s a split-pane view that shows both the storyboard and your code. In this example, we’ll reference a button that’s already been placed on the storyboard:

  1. First, ensure that you’ve completed the steps above to associate the view controller class with the corresponding view controller in the storyboard.
  2. Choose the assistant editor by clicking the icon that looks like this:


3. A split-pane view will open, with the storyboard on the left and your view controller class on the right.

4. Select the button in your storyboard and, while holding down the Control key, drag from the button to the interface area of your code.


5. The resulting dialog will enable you to create an “outlet” for the button in your code. Simply give the button a name, and click the “Connect” button in the dialog. You may now reference the button in the view controller from your code.

6. Let’s hook up a method to be invoked when a person taps on the button. Select the button again, and use the same Control-and-drag maneuver to drop a reference into the interface section of your view controller.

7. This time, in the dialog box that appears, we’ll associate an “action,” rather than an outlet. Choose “Action” from the “Connection” drop-down menu, and enter a name like this:


For the “Event,” use the default of “Touch Up Inside,” and press the “Connect” button.

8. Note that your class now has an interface with two entries in it:

@interface FTSettingsViewController ()
@property (weak, nonatomic) IBOutlet UIButton *myButton;
- (IBAction)tappedMyButton:(id)sender;

The IBOutlet item is used to identify anything that you’re referencing from the storyboard, and the IBAction is used to identify actions that come from the storyboard. Notice also that Xcode has an empty method where you can place the code to be run when the user taps on the control:

- (IBAction)tappedMyButton:(id)sender {

The process above does take some getting used to and could certainly be made more intuitive. After some practice, it will get less awkward. You might find it useful to bookmark the section of the Xcode documentation that describes how to “Connect User Interface Objects to Your Code.”

As we’ll see later, you can also add objects to the view and manipulate their properties programmatically. In fact, applications of even moderate complexity typically perform a lot of manipulation in code. For complex apps, some developers eschew the storyboard and use the code-based alternative almost entirely.


For even the most basic of applications to function, some code must be written. So far in the storyboard, we’ve laid out our user interface and the interactions between the view controllers. But no code has been written to perform the calculations, to persist the settings of the tip percentage and so on. That is all done by you, the developer, in Objective-C.

When an application is running, its overall lifecycle is handled by something called an“application delegate.” Various methods in this delegate are called when key events in the application’s lifecycle occur. These events could be any of the following:

  • the application is started,
  • the application is moved to the background,
  • the application is brought to the foreground,
  • the application is about to be terminated,
  • a push notification arrives.

The events above are handled in a file called AppDelegate. For our sample application, the default handling of these events is just fine; we don’t need to take any special action. The documentation has an overview of the application’s lifecycle and of responding to changes in an app’s state.

The next area of attention is the view controller. Just as with the application delegate, the view controller has its own lifecycle. The view controller’s lifecycle includes methods that are invoked when the following happens:

  • the view controller has been loaded;
  • the view controller is about to appear or has appeared on the screen;
  • the view controller is about to disappear or has disappeared from the screen;
  • the bounds of the view have changed (for example, because the device has been rotated) and the view will be laid out again.

The main code for our application is in the FTViewController.m file. Here is the first bit of code that initializes our screen:

- (void)viewWillAppear:(BOOL)animated
    // Restore any default tip percentage if available
    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
    float tipPercentage = [defaults floatForKey:@"tipPercentage"];
    if (tipPercentage > 0) {
        _tipPercentage = tipPercentage;
    } else {
        _tipPercentage = 15.0;
    self.tipAmountLabel.text = [NSString stringWithFormat:@"%0.2f%%", _tipPercentage];

In this application, we want to use whatever tip percentage value was stored in the past. To do this, we can use NSUserDefaults, which is a persistent data store to hold settings and preferences for an application. Keep in mind that these values are not encrypted in any way, so this is not the best place to store sensitive data, such as passwords. A KeyChain API is provided in the iOS SDK to store such data. In the code above, we’re attempting to retrieve the tipPercentage setting. If that’s not found, we’ll just default to 15%.

When the user taps the “Calculate Tip” button, the following code is run:

- (IBAction)didTapCalculate:(id)sender {
    float checkAmount, tipAmount, totalAmount;

    if (self.checkAmountTextField.text.length > 0) {

        checkAmount = [self.checkAmountTextField.text floatValue];
        tipAmount = checkAmount * (_tipPercentage / 100);
        totalAmount = checkAmount + tipAmount;

        self.tipAmountLabel.text = [NSString stringWithFormat:@"$%0.2f", tipAmount];
        self.totalAmountLabel.text = [NSString stringWithFormat:@"$%0.2f", totalAmount];


    [self.checkAmountTextField resignFirstResponder];


We’re simply reading the value that the user has inputted in the “Amount” field and then calculating the tip’s value. Note how the stringWithFormat method is used to display thetipAmount value as a currency value.

When the user taps the “Settings” button in the navigation controller, the segue that we established in the storyboard will push the settings’ view controller onto the stack. A separate view controller file, FTSettingsViewController, will now handle the interactions on this screen. Pressing the “Done” button on this screen will run the following code:

- (IBAction)didTapDone:(id)sender {

    float tipPercentage;
    tipPercentage = [self.tipPercentageTextField.text floatValue];

    if (tipPercentage > 0) {

        NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
        [defaults setFloat:tipPercentage forKey:@"tipPercentage"];
        [defaults synchronize];

        [[self navigationController] popViewControllerAnimated:YES];

    } else {

        [[[UIAlertView alloc] initWithTitle:@"Invalid input"
                                    message:@"Percentage must be a decimal value"
                          otherButtonTitles:nil] show];



Here we’re retrieving the value from the text field and making sure that the inputted value is greater than 0. If it is, then we use NSUserDefaults to persist the setting. Calling the synchronize method is what will actually save the values to storage. After we’ve saved the value, we use the popViewControllerAnimated method on the navigation controller to remove the settings view and return to the prior screen. Note that if the user does not fill in the percentage correctly, then they will be shown the standard iOSUIAlertView dialog and will remain on the settings screen.

In the section above on view controllers and storyboards, I mentioned that the controls in a view can be manipulated programmatically. While that was not necessary for our application, the following is a snippet of code that creates a button and adds it to a particular location on the screen:

CGRect buttonRect = CGRectMake(100, 75, 150, 80);
UIButton *myButton = [UIButton buttonWithType:UIButtonTypeRoundedRect];
myButton.frame = buttonRect;
[myButton setTitle:@"Click me!" forState:UIControlStateNormal];
[self.view addSubview:myButton];

Generally speaking, all of the controls that you place in a view extend from an ancestor class named UIView. As such, buttons, labels, text-input fields and so on are all UIViews. One instance of a UIView is in the view controller. This can be referenced in your view controller’s code as self.view. The iOS SDK positions items in a view based on a frame, also referred to as CGRect, which is a structure that contains the x and y coordinates of the item, as well as the width and height of the object. Note in the code above that the button is instantiated and assigned a frame (location and size) and then added to the view controller’s view.


When Xcode and the iOS SDK are installed, so is the iOS simulator, which simulates an iOS device directly on your machine. Xcode has a drop-down menu that allows you to select different device configurations. Pressing the “Run” button in the upper-left corner will build the app and then run it in the chosen simulator.


Using the menu above, you can switch between iPhones and iPads of different sizes, as well as between Retina and non-Retina versions of each device.

Debugging is done simply by clicking in the left margin of the code editor, where the line numbers appear. When the execution of your app reaches the breakpoint, the app will stop and the variable values in effect at that moment in time will appear below the code editor:


Some things, such as push notifications, cannot readily be tested in the simulator. For these things, you will need to test on a device, which requires you to register as an Apple developer for $99 a year. Once you have joined, you can plug in your device with a USB cable. Xcode will prompt you for your credentials and will offer to “provision” the device for you. Once the device is recognized, it will be shown in the same menu that allows you to switch between device simulators.

In Xcode, by going to Window → Organizer in the menu, you can display a tool that enables you to manage all of the devices visible in Xcode and to examine crash logs and more. The Organizer window also lets you take and export screenshots of your application.


Source: Four Ways To Build A Mobile Application, Part 1: Native iOS BLOG

Author: Peter Traeg

Referenced site: http://www.smashingmagazine.com/2013/11/22/four-ways-to-build-a-mobile-app-part1-native-ios/

Native, HTML5, or Hybrid: Understanding Your Mobile Application Development Options

Screens are small, apps are big, and life as we know it is on its head again. In a world that's increasingly social and open, mobile apps play a vital role, and have changed the focus from what's on the Web, to the apps on our mobile device. Mobile apps are no longer an option, they're an imperative. You need a mobile app, but where do you start? There are many factors that play a part in your mobile strategy, such as your team’s development skills, required device functionality, the importance of security, offline capability, interoperability, etc., that must be taken into account. In the end, it’s not just a question of what your app will do, but how you’ll get it there.

Like Goldilocks, you may have to try a couple beds that are too soft or too hard, before you find the one that’s just right. And sometimes there’s just no perfect choice. Each development scenario has its pros and cons, and those might in be inline, or at odds, with your means. Unlike Goldilocks, there are no bears to contend with, and it’s our intent that this article keeps you from burning your lips on hot porridge (well, figuratively).

While this article addresses mobile app development in general, it is specifically targeted at developers looking to create mobile applications that interact with Salesforce.com, Force.com, or Database.com. Currently, the Salesforce Mobile SDK supports building three types of apps:

  • Native apps are specific to a given mobile platform (iOS or Android) using the development tools and language that the respective platform supports (e.g., Xcode and Objective-C with iOS, Eclipse and Java with Android). Native apps look and perform the best.
  • HTML5 apps use standard web technologies—typically HTML5, JavaScript and CSS. This write-once-run-anywhere approach to mobile development creates cross-platform mobile applications that work on multiple devices. While developers can create sophisticated apps with HTML5 and JavaScript alone, some vital limitations remain at the time of this writing, specifically session management, secure offline storage, and access to native device functionality (camera, calendar, geolocation, etc.)
  • Hybrid apps make it possible to embed HTML5 apps inside a thin native container, combining the best (and worst) elements of native and HTML5 apps.



Native Mobile Applications

In a nutshell, native apps provide the best usability, the best features, and the best overall mobile experience. There are some things you only get with native apps:

  • Multi touch - double taps, pinch-spread, and other compound UI gestures
  • Fast graphics API - the native platform gives you the fastest graphics, which may not be a big deal if you’re showing a static screen with only a few elements, or a very big deal if you’re using a lot of data and require a fast refresh.
  • Fluid animation - related to the fast graphics API is the ability to have fluid animation. This is especially important in gaming, highly interactive reporting, or intensely computational algorithms for transforming photos and sounds.
  • Built-in components - The camera, address book, geolocation, and other features native to the device can be seamlessly integrated into mobile apps. Another important built-in components is encrypted storage, but more about that later.
  • Ease of use - The native platform is what people are accustomed to, and so when you add that familiarity with all of the native features they expect, you have an app that’s just plain easier to use.
  • Documentation - There are over 2500 books alone for iOS and Android development, with many more articles, blog posts, and detailed technical threads on sites like StackOverflow.

Native apps are usually developed using an integrated development environment (IDE). IDEs provide tools for building


debugging, project management, version control, and other tools professional developers need. While iOS and Android apps are developed using different IDEs and languages, there’s a lot of parity in the development environments, and there’s not much reason to delve into the differences. Simply put, you use the tools required by the device.

You need these tools because native apps are more difficult to develop. Likewise, the level of experience required is higher than other development scenarios, you don’t just cut and paste Objective-C and expect it to work. Indeed, the technological know-how of your development team is an important consideration. If you’re a professional developer, you don’t have to be sold on proven APIs and frameworks, painless special effects through established components, or the benefits of having your code all in one place. Let’s face it, today a skilled native iOS or Android developer is a rock star, and can make rock star demands.

While we’ve touched on native apps from a development perspective, there’s also the more important perspective: the end user. When you’re looking for an app, you’ll find it in the store. When you start the app, it fires up immediately. When you use the app, you get fast performance, consistent platform look and feel. When your app needs an update, it tells you so. Native apps give you everything you’d expect from the company that built your device, as if it were simply meant to be.

HTML5 Mobile Applications

If you’re new to mobile app development, you’re late to the party. However, for mobile Web-based apps, we’re still partying like it’s 1999! Sure, browsers have gotten better in the past umpteen years, but the underlying technology isn’t that much different than when you feared the Y2K bug.

But that can be a good thing. An HTML5 mobile app is basically a web page, or series of web pages, that are designed to work on a tiny screen. As such, HTML5 apps are device agnostic and can be opened with any modern mobile browser. And because your content is on the web, it's searchable, which can be a huge benefit depending on the app (shopping, for example).


If you have experience developing Web apps, you'll take to HTML5 like a duck to water. If you're new to Web development, the technological bar is lower; it's easier to get started here than in native or hybrid development. Unfortunately, every mobile device seems to have their own idea of what constitutes usable screen size and resolution, and so there's an additional burden of testing on different devices. Browser incompatibility is especially rife on Android devices, so browser beware.

An important part of the "write-once-run-anywhere" HTML5 methodology is that distribution and support is much easier than for native apps. Need to make a bug fix or add features? Done and deployed for all users. For a native app, there are longer development and testing cycles, after which the consumer typically must log into a store and download a new version to get the latest fix.

In the last year, HTML5 has emerged as a very popular way for building mobile applications. Multiple UI frameworks are available for solving some of the most complex problems that no developer wants to reinvent. iScroll does a phenomenal job of emulating momentum style scrolling. JQuery Mobile and Sencha Touch provide elegant mobile components, with hundreds if not thousands of plugins that offer everything from carousels to super elaborate controls.

So if HTML5 apps are easier to develop, easier to support, and can reach the widest range of devices, where do these apps lose out? We already reviewed the major benefits of native development, so we'll just reiterate that you can't access native features on the device. Users won’t have the familiarity of the native look and feel, or be able to use compound gestures they are familiar with. But strides are being made on all fronts, and more and more functionality is supported by browsers all the time.

The latest batch of browsers support hardware accelerated CSS3 animation properties, providing smooth motion for sliding panels as well transitions between screens, but even that can’t match the power and flexibility of native apps. Today, it’s simply not possible to capture multi-touch input events (determining when more than one finger is on the screen) or create path-style elegance with spinout buttons and photos that hover, then drop into the right place.

However, significant limitations, especially for enterprise mobile, are offline storage and security. While you can implement a semblance of offline capability by caching files on the device, it just isn't a very good solution. Although the underlying database might be encrypted, it’s not as well segmented as a native keychain encryption that protects each app with a developer certificate. Also, if a web app with authentication is launched from the desktop, it will require users to enter their credentials every time the app it is sent to the background. This is a lousy experience for the user. In general, implementing even trivial security measures on a native platform can be complex tasks for a mobile Web developer. Therefore, if security is of the utmost importance, it can be the deciding factor on which mobile technology you choose.

Hybrid Mobile Applications

Hybrid development combines the best (or worst) of both the native and HTML5 worlds. We define hybrid as a web app, primarily built using HTML5 and JavaScript, that is then wrapped inside a thin native container that provides access to native platform features. PhoneGap is an example of the most popular container for creating hybrid mobile apps.

For the most part, hybrid apps provide the best of both worlds. Existing web developers that have become gurus at optimizing JavaScript, pushing CSS to create beautiful layouts, and writing compliant HTML code that works on any platform can now create sophisticated mobile applications that don’t sacrifice the cool native capabilities. In certain circumstances, native developers can write plugins for tasks like image processing, but in cases like this, the devil is in the details.

On iOS, the embedded web browser or the UIWebView is not identical to the Safari browser. While the differences are minor, they can cause debugging headaches. That’s why it pays off to invest in popular frameworks that have addressed all of the limitations.


You know that native apps are installed on the device, while HTML5 apps reside on a Web server, so you might be wondering if hybrid apps store their files on the device or on a server? Yes. In fact there are two ways to implement a hybrid app.

  • Local - You can package HTML and JavaScript code inside the mobile application binary, in a manner similar to the structure of a native application. In this scenario you use REST APIs to move data back and forth between the device and the cloud.
  • Server - Alternatively you can implement the full web application from the server (with optional caching for better performance), simply using the container as a thin shell over the UIWebview.

Netflix has a really cool app that uses the same code base for running the UI on all devices: tablets, phones, smart TVs, DVD players, refrigerators, and cars. While most people have no idea, nor care, how the app is implemented, you’ll be interested to know they can change the interface on the fly or conduct A/B testing to determine the optimal user interactions. The guts of decoding and streaming videos are delegated to the native layer for best performance, so it’s a fast, seemingly native app, that really does provide the best of both worlds.


Source: Native, HTML5, or Hybrid: Understanding Your Mobile Application Development Options BLOG

Author: Mario Korf and Eugene Oksman

Referenced site: https://developer.salesforce.com/page/Native,_HTML5,_or_Hybrid:_Understanding_Your_Mobile_Application_Development_Options






There are dozens of great CMSs out there. Regardless of what type of site you’re building, there’s probably one perfectly-suited to it.

The problem is that most designers and developers don’t want to spend time learning a bunch of different CMSs. They want to learn one, or maybe two, and use those for all of their sites. That means they need something that’s both flexible and powerful.

The CMSs below fit that bill pretty well. Some have practically become household names (in designer households, at least), while others are a bit more obscure.

The first three, WordPress, Joomla!, and Drupal, are pretty unarguably the best CMSs out there. The next seven are a bit more subjective, but have a good combination of support, features, and ease-of-use.

Try them out, and decide for yourself which one best fits your needs and the needs of your clients.


Free, PHP-based



A couple years ago, it was widely debated whether WordPress should really be considered a CMS considering its roots as a blogging platform. That debate has pretty much fallen by the wayside at this point, as WordPress now powers plenty of non-blog websites, including everything from simple multi-page brochure style sites right up to full-fledged social networks (using plugins like BuddyPress).
There are thousands of themes available for WordPress, as well as thousands of plugins and widgets to extend its functionality. WordPress also has an incredibly active community surrounding it, meaning it’s easy to find tutorials or information about nearly every aspect of developing for WP.
Through plugins and custom themes, you can turn WP into a social network, forum, e-commerce site, and much, much more. There’s also built-in functionality for creating blog networks or other multi-blog installations from a single core installation. WordPress.com offers a hosted, less-versatile version of WordPress, though the basic functionality is all there.


  • Huge developer community with plenty of documentation and tutorials available
  • Free and paid plugins and specialized themes make it possible to create virtually any kind of site with WordPress
  • User-friendly dashboard for managing content


  • Can be overkill for basic sites
  • A standard installation can have a lot of security issues, and is very vulnerable to attack without additional security measures
  • No official support outside of user forums, where you may or may not get an official response


Free, PHP-based


Joomla! is used by some very prominent companies as the CMS for their websites, including MTV, Harvard University, and IHOP. It’s suitable for back-end networks, too, and is used by Citibank for just that purpose. Joomla! has been used for everything from inventory control systems to reservation systems, to complex business directories, in addition to normal websites.

Joomla! has a long development history and a very active developer community (with over 200,000 users and contributors), so finding information and tutorials is easy. There are also tons of plugins and add-ons for Joomla!, so extending Joomla!’s functionality doesn’t necessarily require any custom coding.

While there are plenty of themes out there for Joomla!, the quality for many doesn’t compare to what’s available for WordPress. There are some great themes, available, though, if you’re willing to look for them.


  • User authentication can be done with OpenID, Google, and LDAP, among others
  • More than 7000 extensions
  • Very active user community and tons of documentation available


  • Back-end isn’t as user-friendly as some CMSs, though it’s still very usable
  • Lack of high-quality themes when compared to some other CMSs
  • Can be overkill for simple sites


Free, PHP-based


Drupal is another very popular CMS, used by a number of high-profile companies including the New York Observer, Popular Science, MIT, Sony Music, Fast Company, and others. It includes a bunch of features for building internal and external sites, and a ton of tools for organizing your content.

Drupal has a very active community, with a number of IRC channels, forums, and even face-to-face Drupal events. There’s also community-generated documentation that is constantly being updated and improved. This documentation includes all you need to know about installation, building sites and modules, designing themes, and more.

There are more than 6,000 add-ons (“modules”) available for Drupal, making it easy to extend Drupal’s functionality to do just about anything you want. This means you can spend your time focusing on design and content, rather than having to code a bunch of complicated features.


  • Robust community support, including IRC channels and face-to-face meetups
  • More than 6,000 modules, making Drupal highly extensible
  • A large number of companies offering commercial support for Drupal


  • Can be overkill for simple sites
  • A lack of really high-quality free and commercial themes (there are some, but not nearly as many as there are for some CMSs)
  • Theming system is fairly complicated


$99.95 to $299.95 depending on license, PHP-based


ExpressionEngine is an interested hybrid of commercial and open-source software. The base code for the ExpressionEngine core is built on CodeIgniter, which is their own open-source PHP framework. But the commercial aspect of the CMS means that there’s committed developers and technical support people focused solely on EE.

There are a ton of great websites built on ExpressionEngine, and they’ve set up a showcase site, Show-EE, specifically to share them. Some sites built on EE include A|X Life, the Canon Ixus site, and LivingSocial Adventures.

ExpressionEngine doesn’t have as many add-ons and plugins as many other CMSs, with only 22 add-on modules and a little over 100 official plugins. But, the plugins and add-ons they have are some of the most likely to be used, and include a wiki, discussion forum, member manager, mailing list, e-commerce, statistics, and more. There are also community plugins, if you can’t find what you need in the official plugins. The core feature set of EE is impressive, too.


  • Commercial support
  • Focus on security, with no major security breaches ever
  • No restrictions on how a site can be designed


  • Cost is high, especially for commercial sites
  • Can be overkill for simple or smaller sites
  • No interactive demo to try it out before you purchase



Free, PHP-based


TextPattern is probably one of the more overlooked CMSs out there. TextPattern is a highly flexible CMS, though, that’s easy to use out of the box and easy to customize by designers and developers. It uses a tagging system to make content retrieval and display easily controllable. TextPattern uses Textile to quickly convert plain text to valid XHTML in your articles and content, which makes it very user-friendly for less technical users.

TextPattern doesn’t have the huge variety of themes or templates available for WordPress, Drupal, or Joomla!, with only a little over 120 front-end themes readily available. They also offer back-end admin themes, for customizing the user experience for content creators.

There are nearly 700 plugins for TextPattern, and another 50+ mods. Plugin categories include image galleries, integrations, e-commerce, custom fields, archives, articles, admin features, navigation, and more. The mods and plugins available greatly increase the functionality of TextPattern and can make it a much more powerful CMS.


  • Really easy to use interface
  • Well suited for sites of all sizes
  • Really great documentation, including a full online manual


  • Smaller community
  • Fewer plugins than the more popular CMSs
  • Relatively few high-quality templates available



Free, PHP-based


Contao has a user interface that incorporate Ajax and other Web 2.0 features to improve usability. It includes advanced editing features for content, including editing multiple records at once or rolling back to prior versions of content.

It also includes a number of common built-in modules. The calendar module supports multiple calendars, all-day and multi-day events, open-ended events, and syndication via RSS or Atom. The built-in newsletter module supports double opt-in emails in either HTML or plain text. You can import recipients from a CSV file, and even personalize newsletters being sent. The build-tin news/blog module includes support for multiple categories, archives, featured posts, comments, and RSS or Atom syndication. Tons of additional modules are also available, to further extend Contao’s functionality.

There are a few premium theme marketplace for Contao, though there appear to be even fewer free themes available. This isn’t really an issue for designers who plan to create all their sites from scratch (and Contao includes a built-in CSS framework to make this easier).


  • No restrictions on how you can design a site
  • Not much learning curve for content editors and authors
  • Good built-in modules


  • Hardly any themes available, high-quality or not
  • Back-end is sluggish and not particularly well-thought-out
  • Because of back-end setup, it’s probably better-suited to smaller sites without dozens or hundreds of pages



Free, PHP-based


SilverStripe is an open source CMS that is well-suited for developers and designers who are comfortable with code. They have recipes and tutorials for beginning developers, and plenty of modules for things like blogs, forms, and forums. Code is isolated in Sapphire, so designers can use whatever HTML and CSS they want to style their sites. It also supports multiple page templates to support different needs.

SilverStripe also has powerful content authoring tools. You can set up your own content approval process, as well as publish or unpublish content on specific dates, and have differing permissions levels for different parts of the site. That can be very useful if you have multiple editors or authors who only need access to a specific part of the site.

SilverStripe has been downloaded over 350,000 times and there is a robust development community. SilverStripe LTD. manages the development of the code, so there’s always someone you can call on if you need help. At the same time, though, they have partners in over 30 countries, meaning you’re not locked into a single vendor like you are with many enterprise-level and commercial CMSs.


  • Basic functions in the back-end are easy to perform
  • Designers are free to use HTML and CSS however they want to design their site
  • Developed on open standards, so it plays well with others


  • Not everything is intuitive in the back-end, which increases the learning curve
  • Only a little over 150 extensions/modules
  • Not many high-quality themes available



Free, .NET-based


Umbraco gives designers full control over design aspects, and focuses on web-standards and a completely open template system. There are starter kits and skins available to make it faster to get started. It’s also easy to integrate Flash and Silverlight content into your Umbraco-based site. A number of high-profile sites are built on Umbraco, including the Heinz and ABBA sites.

On the content-creation side, Umbraco makes it easy to manage content by using a tree-based view of your site. It allows for user-defined presentation of information about your content, so you only see what you need to. It supports versioning, scheduled publishing, and previews. One advantage Umbraco has over many other CMSs is that it works well with content created in Microsoft Word, which can be a huge advantage to users who are used to dealing with Office products. (How many times have clients sent you documents with detailed Word formatting that they expected you to recreate perfectly?)

Umbraco has support for developers and designers to customize the back end with custom applications. It has an open API so that developers can easily access every aspect of Umbraco that can be accessed via the back-end. This opens up a ton of custom application options for developers.


  • Free and paid tutorials and support
  • Powerful and flexible for both websites and intranets
  • An open API


  • Primary add-ons are paid
  • No demo available to try before you download
  • Not really any prebuilt themes available for the front-end


Free, PHP-based


concrete5 is not only a powerful CMS, but can also be used as a framework for developing web apps. Designing sites is easy, and can be done at a variety of levels. You can start with a theme and then override styles without touching the code. Or you can code your own themes with HTML and CSS. If you’re comfortable with PHP, you can use custom templates that can override the way any block looks.

One advantage concrete5 has over some other CMSs is the in-context editing. They’ve attempted to replicate the functionality of a word processor, while also making it simple to edit pages as you view them. It makes it very user-friendly for non-technical users, who may be the ones managing the site’s content.

According to the 2010 Open Source CMS Market Share Report, concrete5’s developer community is the fastest growing among any open source CMS. They have a very active community, with how-tos geared toward designers, add-ons and themes with actual support, and even support ticketing if you run into an issue that can’t be solved on the forums. The community and support surrounding concrete5 make it a very appealing CMS for users at the beginning and intermediate levels.


  • Easy to convert a basic HTML site to a concrete5 site in minutes
  • Active and growing developer community
  • Offer business-class hosting that includes support


  • Many useful and basic plugins are quite costly
  • Almost all of the best themes are paid
  • Paid support is expensive if you don’t host with them ($125 and up)


Free – $28/month depending on feature set, hosted


CushyCMS is the only hosted CMS on this list. There’s a limited-feature free version that includes an unlimited number of sites, pages, and editors, but doesn’t let you use your own logo or your own domain name for the admin panel, or customize the admin experience. If you don’t care about your own branding in the admin panel, it may work for your business. The paid version, which is $28/month, has many more features, including branding support.

The main thing that sets CushyCMS apart from most others is that it’s specifically meant to make it easy for your clients to edit their own content. You design the website however you want, and then add it to the CushyCMS account. From there you can define which parts are editable and give your clients access.

Because of the nature of CushyCMS, there are no plugins or pre-defined themes. But for designers who might not be used to working with a CMS, or who design a lot of basic sites that don’t really need a full-featured CMS, but do need to be editable by their clients, CushyCMS is a great option.


  • Incredibly easy for content managers to edit their content
  • Free plan is suitable for many users
  • Very easy and quick to get started


  • Paid plan could be pricey if you’re not using it for multiple sites
  • Email support only available for the paid version
  • Too basic for many types of sites or particularly large sites



Referenced site: http://www.webdesignerdepot.com/2011/10/top-10-content-management-systems/





The True Cost of Building and Managing a WordPress Website

In any description of WordPress features, there’s one word you’re sure to see:


This is, of course, true. The files necessary to install WordPress on a server and run it are indeed free.

A casual content producer could even sign up at WordPress.com and run their entire website for free, never paying a dime if all they wanted were the most basic features.

But you are no casual content producer. Right?

You use WordPress like we use WordPress: as a serious business tool to drive serious revenue.

You understand — like we do — that the true cost of running WordPress is far from free.

So what is that true cost?

And how can you minimize the total cost of WordPress ownership while maximizing its potential to manage the online content that drives your business?

WordPress Total Cost of Ownership Analysis

To use WordPress as a tool for building a business online or off, it needs to be viewed not as “free blogging software”, but as a legitimate business acquisition.

Total Cost of Ownership (TCO) analysis is a time-tested model of cost assessment for important business acquisitions that has been in use in the IT world since the early days of computers.

In IT, as with vehicles and other complex goods, total cost can vary greatly from purchase price.

There are obvious costs to consider (like purchase price and regular maintenance), but there are also other “real costs” that often get overlooked; and if a real cost will indeed follow the decision to acquire or use something, it needs to be taken into account.

Just how many real costs can there be to consider? Potentially, a lot.

What are some of the hidden costs associated with WordPress management?

  • Domain registration
  • Hosting
  • Premium theme
  • Developer fees
  • Security services
  • Storage and backups
  • Personal time

The key is to understand and assess each of these real costs and how it is impacted by different WordPress management strategies. This will allow you to make choices that will maximize the potential of WordPress for your business, while minimizing your costs along the way.

What are the different ways you can manage your WordPress-backed website?

  • WordPress.com
  • Self-Hosted
  • Managed WordPress Hosting
  • Premium Managed WordPress Hosting

Since WordPress itself is always free to acquire, let’s analyze the real costs of each of the options above.

Note: to keep this relatively simple, we’re sticking with the hidden costs as listed above. There are surely others based on individual circumstances, and the comment section of this article will be a great place to break these out.

Hosting Your Site on WordPress.com

If you run your site on WordPress.com, you receive a basic level of shared hosting free. However, to have your own domain (as opposed to yoursite.wordpress.com)it’ll cost you between $18-25 per year.

Additionally, if you choose to go with a premium theme, you’ll have to use one of the WordPress.com-only premium themes, which will run somewhere around $70 and cannot be transferred should you choose to self-host at a later date.

You won’t have to worry about any security costs because Automattic, the company behind WordPress.com will manage this for you.

In total, consider a simple TCO of roughly $95 for the first year, with a recurring charge for the domain.

Though WordPress.com is a great option for the casual content producer, you’ll be limited in configurations, themes, plugins, and other aspects of content management that could impact your ability to connect with your audience, achieve maximum SEO benefits, and commercialize your site.

The Self-Hosted Option

If you want to host your site yourself, rather than on WordPress.com, you can go to a generic hosting provider and get very “affordable” shared hosting for as little as $4.24 per month. Granted, your site will live on a massive shared server, so performance will suffer, but your site will be up and running.

Unlike WordPress.com, self-hosting your website gives you unlimited theme options. You can choose a free one from the WordPress themes repository, purchase a premium theme, or develop your own. Most serious small business owners do not find free themes to their liking for numerous reasons, and most also do not have the know how nor the capital to pay a developer for a custom theme. This makes premium themes a great choice.

Our AgentPress theme from StudioPress, for example, runs $99.95. Others can be had for $79.95. For the purposes of this analysis, a $79.95 figure seems like a reasonable splitting of the difference between a free theme and the developer costs of a custom theme.

How about security?

Fortunately there are free options like Sucuri’s WordPress monitoring plugin. However, unless you are paying for a VPS, your site will be on a shared server with scores of others. Each of these sites is a potential security risk to the server, and therefore, to you.

If you get hacked or the server goes down, there will be costs associated with downtime, the de-hacking process, and recovering lost files. And if you are not well versed in these processes, you’ll have to hire someone to help you.

You’ll also be responsible for storing your own backups. In the case of a catastrophic hacking or data loss event, these are handy to have. There is, of course, a cost associated with it though.

Just with fees for bare-minimum hosting and the price of a theme, the total cost is around $125 per year, bare minimum. Consider additional costs for security and storage, and the total cost of self-hosting a WordPress blog that will not be anywhere near high performance is easily $150 with the potential for it to be a lot more.

And, this does not figure in intangible costs like time and peace of mind.

“Regular” Managed WordPress Hosting

The next step up from self-hosting is a managed hosting provider. This allows you to “self host” but with help and guidance from people who should be able to help you manage areas you know nothing about so you can manage your business.

Rates can vary, but most small businesses can get a WP-optimized managed plan for somewhere around $50 per month. You will still be on a shared server, but in a shared environment where they tend to understand WordPress security and support much better than a generic hosting provider that does it all.

If you want to be on a dedicated VPS or run WordPress Multisite, these plans will usually not cover you, so you’ll have to bump to a next level plan that can run between $125-150 per month.

As for themes to design your site, you will still need to purchase one separately, so consider roughly $79.95 for this expenditure.

If the regular small business plan works, consider the total cost to be around $679.95 for the first year.

Premium Managed WordPress Hosting

With premium managed hosting (like what we provide here at Synthesis), access to the Genesis framework comes as part of the package.

In addition — even in the Standard plan — all security, storage, and support are included and delivered at top of the line levels. This is where the value of premium managed hosting, like what we provide here at Synthesis, really shines through.

There is immense value in having the backing of experts who’ve specialized their servers for the idiosyncrasies of hosting and securing a WordPress website. More so, there is value in having a team of people in your corner who not only know hosting but know content, promotion, and design as well.

A generic host — and even some managed hosts — may not be able to answer an intricate question about how adding a thousand 301s will impact SEO.

They might not be able to help out in diagnosing a problematic RSS feed or give recommendations on the best way to integrate a form for capturing email subscribers.

At a place like Synthesis, the support staff can and will … because we’ve all been there.

We provide expert support and proactive advice with the empathy of experience. That’s tough to quantify into a neat and tidy value for TCO purposes, but it will certainly save you time, money, and frustration. And there is no more real a cost in business than time.

But let’s get back to the numbers, because even they paint a compelling picture with a premium WordPress hosting provider.

If you only have one site, and the regular small business plan works — as in the regular managed hosting example above — the total cost of WordPress ownership in that first year is just $564, which is over $100 less.

The Value of Premium Managed WordPress Hosting

There really has not been a formalized TCO study performed for WordPress. And what you see above is far from complete. This was intentional.

What we have tried to do here is simply give you a rough idea of the real costs involved with owning and running a WordPress site. What you’ll have to do to take it the next step is figure out that number associated with your personal or professional time.

For a service provider, this is easy. For every hour they spend trying to fix, de-hack, or improve their site, the costs range from $75 (developer) to $400 (attorney) per hour.

If you are a business, the costs could be greater, even if less obviously quantitative, as your reputation could be damaged if your site were hacked with pornography links or your phones stop ringing due to the site not working.

Or you might be an independent media producer who’s looking to derive more revenue from your site, and the time you spend trying to fix your site takes you away from your family … which is, of course, priceless.


Source: The True Cost of Building and Managing a WordPress Website BLOG

Author: Jerod Morris

Referenced site: http://websynthesis.com/the-true-cost-of-building-and-managing-a-wordpress-website/

The Email Marketing Advantage for Small Businesses

Sometimes, in an attempt to target new customers, small businesses tend to ignore existing clients. Although it might take a fair bit of convincing on the part of designers, most small businesses eventually create an email marketing campaign to leverage existing clients.

Email marketing is suitable for small businesses for a number of reasons. Email campaigns are economical and can compliment the business model of almost every small organization. Most small businesses are able to provide quality service as compared to larger corporations. Due to the exceptional quality of work, people tend to view the work of small businesses as genuine, sincere and trustworthy and are usually more willing to give their email addresses to such vendors.

Here are some good reasons for small businesses to leverage email marketing:


1. It is economical

Usually, most small businesses create special offers, promotions and reminders for their customers, in the form of printed material. Converting this material into email format is not only quick and simple but also results in saving on print and postage expenditure.
Sending an email does not cost anything, especially when compared to the cost of printing and posting material. Sending emails is an inexpensive way of marketing business products and services. Also, emails are created in the form of blank templates. A user simply needs to populate the template to use it. Once the initial cost has been covered, using email involves minimum expenses.
Email marketing allows small businesses to manage their campaigns successfully without hiring new employees or increasing the workload of existing staff. This way, small businesses save on money and time.

2. It can be used to provide important data


Email marketing allows small businesses to target the right audiences. Also, it provides special tools to analyze and accurately measure responses to the email campaign.
An email marketing campaign provides small businesses with important data such as:
- open rates
- clicked links
- conversion details

3. It is quick

Email marketing is one the quickest forms of communication. It enables you to provide customers with immediate information and also allows instant access to their replies and queries.
With email marketing, you can receive responses to your marketing campaign within 1 to 3 days. This is a really short turnaround time, especially when compared to the speed of direct mail campaigns which can take up to 12 days for a response.

4. It is convenient

Email marketing allows convenient placement of links to important products and services; placing links within your emails in a location most likely to grab the reader’s attention is an easy way to boost revenues.
Email marketing makes it is possible to update email lists quickly. Using emails also enables comments, queries and feedback to be updated quickly, allowing easy management of the inbox! Also, email campaigns contain links to subscribe and unsubscribe, which makes it convenient to separate interested subscribers from the disinterested ones.

With all these great advantages, it is quite clear that email marketing campaigns are the future of small businesses. Don’t miss out on its benefits; go ahead and create an email marketing campaign right away!


Source: The Email Marketing Advantage for Small Businesses BLOG

Author: Benchmark

Referenced site: http://www.benchmarkemail.com/resources/email-marketing-articles/Email-Marketing-Advantage-for-Small-Businesses

What Is Email Marketing?

Email marketing is directly marketing a commercial message to a group of people using electronic mail (email). Though it is more commonly thought of as using email to send ads, request business, or solicit sales or donations, any email communication that is meant to build loyalty, trust or brand awareness qualifies.

What Is Professional Email Marketing?

By the above definition, any email communication sent on behalf of a business or organization qualifies as email marketing – even if it only contains text. Professional Email Marketing is

employing a service or program that provides:


Permission Based List Building - Also known as “double opt-in,” this is the creation of an email list by providing a signup box for prospective email contacts and confirming their approval with a follow-up email.


List Management - The ability to organize, edit, segment, grow and manage a database of customer or client email contact information.

features04Rich Content Integration - The addition of graphics, audio, video and text using templates and a “drag-n-drop” editor.
email_extCampaign Creation - The capability to organize and structure large volumes of email messages by theme, branding and schedule.

unsubscribeUnsubscribe Features - Providing the potential for an email contact to quickly and successfully be removed from future campaigns should the person no longer wish to participate in your promotions.

features09Online Reporting - The means to track the sending of individual email campaigns, at what rates they were opened and which emails were “bounced” as undeliverable to bad addresses.

Advantages of Professional Email Marketing

tickBetter Business Communication - Your email is organized and has an appearance that is befitting a company or organization that is professional.

tickTarget Marketing - Because you can use custom fields to sort and segment your contact list into smaller lists, you tailor your promotions effectively by demographics.

tickVery Cost Effective - Email Marketing is cheaper than traditional mail because there is no postage to buy.
tickEnvironmentally Friendly - There is no paper to print and ink is not involved in your communications.


Source: What Is Email Marketing? BLOG

Author: Benchmark

Referenced site: http://www.benchmarkemail.com/resources/email-marketing-articles/what-is-email-marketing


Email Marketing: How to Push Send and Grow Your Business

Email Marketing strikes many as old-fashioned. More fashionable venues like social media and mobile marketing get all the attention, and some people will even try to tell you that email marketing is dead.

Unfortunately, reality doesn’t agree. In fact, with a strong content marketing approach, email is more powerful than ever thanks to social media.





Because it moves the conversation about your business to a more personal environment — the in-box.


Email provides you the most direct line of communication for conversion to sales … which is why the most savvy online

 marketers have no intention of giving it up any time soon.

It’s also amazingly cost-effective. With an ROI of around 4,300% (according to the Direct Marketing Association), email practically pays for itself … and saves a tree or two. It’s what you use when you want to move from “conversation to commerce.”


What makes email content work?


All of us are far too familiar with email newsletters that waste our time, pitches that annoy us, and downright spam.Those don’t work.

What works is a value exchange — your valuable information for your prospect’s valued time. Your subscribers need to know they can trust you … that you’re not a soulless self-promoting spam-bot.

Good email content deepens your relationship with your audience through effective subject line writing (getting your messages opened), your distinctive voice (getting those messages read), and delivering quality, niche specific content your prospect needs and shares with others (inspiring referrals and word-of-mouth).


Source: Email Marketing: How to Push Send and Grow Your Business BLOG

Author: Brian Clark

Referenced site: http://www.copyblogger.com/email-marketing/

1 2 3 4 5 6 7


Use the contact form to send me an email below

Keep in touch

You can use the following information to contact me or anything you need to communicate if you want to join me.

Name: Rypaci Marketing Solution Administrator
Phone: (082)282-2713
Skype: ryans_ians
Address: Circumferential road mineral village - chio building Bajada Davao City