CSC/ECE 517 Fall 2009/wiki3 21 MobileDesignPattern

Design Pattern for Mobile Applications

The popularity of mobile applications is rising. Design patterns are useful in almost any coding tasks. While almost any design pattern could be used within mobile applications, certain patterns are well suited for the unique environment of mobile applications. This paper focuses first on the mobile application environment, then on design patterns that work well within this new emerging environment.

The Mobile Application Environment

The mobile application environment is new and presents many unique opportunities and challenges for developers. It seems almost everyone now has a cellphone, blackberry, or other small portable device. These devices are "getting smarter" in that many people are developing new applications for them. Cell phones no longer are just used to call people, they often have features like text messaging, cameras, video games, web browsers and more. There is much opportunity for developers to write new applications for mobile devices.

While opportunity abounds, there are also quite a few challenges. Mobile applications have less resources than are typically found in other development environments. The screen om mobile devices is typically smaller, there is usually not a keyboard and mouse (user inputs are reduced). [5] CPU resources are generally less than those found in the typical environment. [7] Power usage is also limited because a battery is typically used, so reducing power use by the application is an important goal. [7] Connections are typically expensive and are often prone to loss of signals. [6]

Another problem is that there is a high demand for applications to be developed quickly. p7[ The mobile environment is changing rapidly. [2] Some of the lower level programming languages were useful because they produced fast applications, but they took too long to develop with. Now, with the increased demand for applications quickly, Object Oriented Programming (OOP) is used more. While this causes a greater usage of resources, this is outweighed by the much quicker development cycle and the re-use of code. In particular, good solutions may be re-used in OOP. [7]

In the mobile environment, applications are often written on different operating systems on different mobile systems. There is increased interaction between mobile systems, especially for cell phones. The Service Oriented Architecture design pattern is especially well suited for this situation. This is a fairly new field, and methods are currently being developed to aid developers.

Ways to Adapt Using Design Patterns

Several principles and patterns have been understood and developed in developing for mobile applications. Many of these methods are still undergoing change and experimentation. There are new methods being developed and others left behind. A design pattern can be defined as a repeatable solution to a common problem in software. It is a template for how to solve the problem, not actual code. [7]

Ease of navigation is a particularly important principle, because of the reduced number of user inputs (for example, buttons from 0 to 9 instead of a mouse and keyboard). Everything in an application should be no more than three clicks away. If a program is too "deep", requiring many clicks, this will be a problem because it takes longer to navigate on a mobile device. If the application is to "broad" as in too many links on one page, the data may not all fit on the screen. One way to mitigate this problem is to reduce functionality, to keep the application as simple as possible. [5]

!!!! Insert EC Factory here

The Model View Controller pattern [1] fits the mobile environment well. Models may be set up so that optimum data structures are used, as was discussed for the EC Factory pattern [7]. Effecient designs may be built into the controllers. Vies could be standardized for the application to handle the small screens.

Notes appear below here: ++++++++++++++++++

Design patterns that are a good fit:

- MVC [1] - Service Oriented Architecture [3] - Mobile Agent Design Model [6] - Meeting Pattern [6]

   - agents (applications / etc...)
   - meeting manager (tracks which agents are "met", facilitates meeting (connection))
   - Multiple PDA search example
   - Marketplace example

- Master / slave pattern [6]

   - Master creates remote slave objects to do tasks, slaves report, slaves reused / destroyed

- Energy Concerned (EC) factory [7]

   - The Factory method is used to return an object of the selected type of class.  For example, a Vehicle factory could be coded to return a class object to a car, plane, or boat, depending on what is desired [7].
   - EC Factory makes use of factories to select energy efficient classes: [7]
       - Generics principle [7]
       - Struct vs. class [7]
       - Static vs. dynamic [7]
   - Make less use of memory, more use of registers because registers require less energy [7]
   - Make minimal use of the CPU
   - Object oriented programming (OOP) consumes more power than procedural programming, but the advantages of code reuse with good designs, and quicker development in OOP outweigh the disadvantages 
   - Use structs vs. classes, and use static vs. dynamic were possible [7]

Stylesheets Forms

of more resource consumption [7] - Model View Controller Framework???? - changes have minimal impact in this [1] http://www.javaworld.com/javaworld/jw-10-2005/jw-1003-mvc.html

References: 1. http://www.javaworld.com/javaworld/jw-10-2005/jw-1003-mvc.html 2. http://patterns.littlespringsdesign.com/index.php/The_mobile_challenge 3. http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki2_17_va - Service Oriented Architecture 4. http://wiki.forum.nokia.com/index.php/Understading_Desing_Patterns - Understanding Design Patterns 5. http://dev.opera.com/articles/view/designing-and-developing-mobile-web-site/ 6. http://portal.acm.org/citation.cfm?id=986710.986726 7. http://portal.acm.org/citation.cfm?id=1292331.1292364

!!!! Note: everything below this point is old and is so we can put in the proper formatting

---

An overview of the concepts

We created this simplified image to illustrate the basic principles of service oriented architectures.

• Services may be used by multiple applications.
• Services do not call on each other.
• Services communicate via protocols.
• An example protocol is provided, in which the application passes x to the Sin function, and Sin(x) is returned.
• Because of the protocol link, services may be written in different programming languages, or even be hosted on different computers with different operating systems, which allows for great flexibility.

language. 7

• Example: Metaprogramming in Ruby [2]

 class Person
   attr_accessor :name
 end

Conclusion

SOA is an evolution of distributed computing based on web services. It is an attractive solution for companies since it is platform independent allowing different software and hardware to communicate together easily.

Metaprogramming and reflection are programming styles used to take advantage of the features in dynamic programming languages. They provide a great advantage when used in the development of SOAs to allow the services to dynamically change and adapt to the messages being passed between services.

References

1. http://www.service-architecture.com/web-services/articles/service-oriented_architecture_soa_definition.html - Brief explanation of SOA

2. Thomas, Dave (2006). Programming Ruby, The Pragmatic Programmers' Guide.

10. Perrotta, Paolo (2009). Metaprogramming Ruby.