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. 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.

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]

- lower resources

   - Low battery power [7]
   - CPU Power [7]
   - Expensive connections [6]
   - Small screens [2]

- Rapidly changing environment [2] - Quick development cycle [7] - Difficult communications (e.g. highly prone to lost data) [6] - Fewer user inputs (often 0-9) so ease of navigation is more important than traditional enviroments [5] - higher communication with other devices - Different underlying operating systems and architectures - At first, code was written in low level languages for mobile devices, but now higher level languages are used to reduce development time. [7]

Design patterns that are a good fit:

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]

- 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.