[Haskell-cafe] GSoC Push Notifications project - communicating with mobile devices

[Marcos Pividori]

Sorry, I am resending this email because I didn't write a correct title
before.
-------

Greetings,

I am a Computer Science student from Argentina. I am interested in working
this summer in a project related to Haskell for the Google Summer of Code.
I have been discussing my idea with Michael Snoyman in order to have a
clearer idea. Now, I would like to know the community interest in this
project.

I want to develop a server-side library in Haskell for sending push
notifications to devices running different OS, such as Android, iOS,
Windows Phone, BlackBerry, and so on.

To pass a subject, I have recently worked with Yesod (a Web Framework based
in Haskell) developing a server to comunicate with Android-powered devices
through Google Cloud Messaging.  (It is available:
https://github.com/MarcosPividori/Yesod-server-for-GCM )

To develop this project, I have read a lot about this service and Yesod
libraries, and I developed two programs, a server written in Haskell and an
Android application for mobile phones. Also, I developed an EDSL to write
programs which exchange information with the devices.

I would be grateful if you could give me your opinion about this project
and the proposal I am starting to write.


*Proposal GSoC 2013:*


*Abstract*

The aim of this project is to develop a server-side library in Haskell for
sending push notifications to devices running different OS, such as
Android, iOS, Windows Phone, BlackBerry, and so on.

The fact is that every company is developing Push Notification services,
and these are very similar. Then, I want to find the fundamental concepts
to construct a library which enable to configure the options for the
different services and send messages easily.

When I say they are very similar, I refer to the fact that they all are
asynchronous, best-effort services that offers third-party developers a
channel to send data to apps from a cloud service in a power-efficient
manner. The most popular are:

- Google Cloud Messaging (Android)

- Apple Push Notification Service (iPhone / iPad)

- Microsoft Push Notification Service (Windows Phone)

- BlackBerry Push Service (BlackBerry)

- Windows Push Notification Services (Windows 8)

- etc.


*Motivation and expected benefits*

I think my idea would be very useful because it will allow all Haskell
developers to open to a new world of mobile devices and to build useful
programs/services that interact with them.

Pushing data to smartphones provides users with instant access to desired
updates as they happen, such as news and weather, sports scores, stock
prices and other time-sensitive content. The push services provide an
efficient way to quickly push timely information updates to many
smartphones at once, in a centrally managed and controlled manner.

Generally, you can also be very selective in who you send information to,
including individual customers or many customers (multicast).

This services minimizes the impact on the smartphones battery life. Instead
of actively checking for new data, the applications can remain closed. Once
the data is delivered, the application can be launched in the background to
process it as needed.

This processes offer an alternative to other less efficient methods, such
as polling, where a device regularly polls an application server to see if
new content is available.

The main differences between the services, refer to details as: the maxim
payload length, the quality of service, queueing the messages or not, and
the time limit for this, the way the messages are handled in the devices,
etc.

As all the libraries to access to these services are developed in Java, I
thought that it would be a good idea to offer an option to Haskell
programmers. Taking advantage of the similarity of these services, I could
develop a very adaptable library which fits the necessities for each one
and at the same time offer an abstraction to the user.

*Deliverables.*


* An API library to build and send messages including:

- GCM and a demo Android app.

- APN and a demo iOS app.

- Microsoft Push Notification Service (Windows Phone) and a demo app.

- Documentation for all the code developed. Including the explantation on
how to use the server library and how to try the demo apps.


* A demo server taking advantage of this libraries to communicate with the
demo apps through push notifications.


* Optionally: (Only in the case that I finalize the rest of the objectives
before the deadline)

- API for communication through BlackBerry Push Service (BlackBerry).

- API for communication through Windows Push Notification Services (Windows
8).


*Technical Considerations*


I have to complete this....


*Timeline*

May 27: (Accepted students announced)

  - 'Community Bonding Period' (~1 month)

    + Get to know mentor(s).

    + Refine this proposal with mentor(s).

    + Set up svn accounts.

    + Set up a wiki page or blog for this project.

    + Make sure that everything is ready for coding.

    + Try to involve the community as much as possible, ask for new
ideas/suggestions/etc.


June 17: (Start of the program)

  - 'Library to use the GCM Service' (Total: ~4 weeks)

    + Familiarize with the GCM service and understand the details related.
(~1 week)

    + Develope the server library to send GCM messages and a demo Android
app. (~2 weeks)

    + Document all the code developed, and check details. (~1 week)


  - 'Library to use the APNS Service' Part 1 (Total: ~2 weeks)

    + Familiarize with the APNS service and understand the details related.
(~1 week)

    + Start to develope the server library to send APNS Push Notifications
and a demo iOS app. (~1 week)



July 29: (Midterm evaluation period begins)

  - 'Midterm evaluation period' (~1 week)

    + Submit the midterm review.



August 2: (Midterm evaluation deadline)

  - 'Library to use the APNS Service' Part 2 (Total: ~2 weeks)

    + Continue to develope the server library to send APNS Push
Notifications and a demo iOS app. (~1 week)

    + Document all the code developed, and check details. (~1 week)


  - 'Library to use the MPNS Service' (Total: ~4 weeks)

    + Familiarize with the MPNS service and understand the details related.
(~1 week)

    + Develope the server library to send MPNS Push Notifications and a
demo Windows Phone app. (~2 weeks)

    + Document all the code developed, and check details. (~1 week)



September 16: (Suggested pencils down date)

  - 'Pencils down' (~1 week)

    + Final code clean up.

    + Present library to the community and analyze feedback.

September 23: (Firm pencils down date)

  - 'Summing up' (~1 week)

    + Submit Final Code to Google.

    + Present final evaluation.

    + Analyze possible future work and document it.

September 23: (Final evaluation deadline)



*About myself and my interest in this project*

-------
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20130428/0d4afe00/attachment-0001.htm>