Mifos and the Google Summer of Code 2010

Congratulations to our 2010 Google Summer of Code (hereafter "GSoC") participants! We've updated the below page to reflect the projects each of these interns will be working on throughout the summer. Attack poverty and complex technical challenges simultaneously.

Get Stoked - End Poverty. One Line of Code at a Time.

What is Mifos

When is the GSoC?

What happpened in the GSoC 2009?

Watch how Mifos technology is helping end world poverty

Learn about Mifos Shared Vision of 3 000 000 000 Maries

Guidelines

Expectations

Students working on Mifos will be expected to:

• use the mifos-developer mailing list
• use the IRC channel
  • please announce yourself, and feel free to share details like: who you are, your IRC nickname, Where are you in studying, what timezone you're in, why you're interested in Mifos. Don't hit and run; plan on hanging around in the channel for a while.
• provide patches
• follow the Mifos coding standards
• document their work
• write and speak fluent English
• have access to reasonable bandwidth, ie: have a fast, reliable Internet connection
• track and report on progress daily

Prerequisite Skills

Basics

• Quick learner
• Troubleshooting Wizard
• Passion for writing beautiful code
• Excellent communication skills
• Knowledge of developer tools
  • such as: a text editor, source control, how to build software
  • experience with specific tools will also help, such as: Eclipse IDE, Subversion, Maven

Mifos includes wide variety of technologies, we do not expect a student to be expert on all of these. But it will be helpful if you have some experience in some of these.

Helpful skills: (specific technology requirements vary with project chosen)

• MySQL, Hibernate, Spring, Struts, Grails
• JSP/JSTL, HTML/XHTML, CSS, JavaScript
• JUnit, TestNG, Selenium

Please also see the list of suggested tools for development with Mifos.

Hints

• When you need help, ask for help! Do some searches before asking, please. We are very excited for you to join us, but we need to know that you're willing to put in the time and effort required to do your part. When you do ask, ask well.
• Not sure if you are qualified? Download and build the code, then run the Web application. Instructions for doing so are available on this wiki.
• Drop by the IRC channel or email the mifos-developer mailing list with your questions and project ideas.
• Install Skype for (generally infrequent) video calls. You'll need a headset for Skype, too.

Mentoring

Mifos folks are constantly working remotely (mainly using Skype), especially in supporting remote contributors. We often do video calls and desktop sharing If possible, we'd love to meet you in person! Specific mentors for each project are listed below.

Project Ideas

Prototype a new Mifos front end using Groovy, Grails and a CSS Framework

Mentor: Van Mittal-Henkle (Unlicensed)

It's hard to understand and modify the current struts, JSP and HTML frontend code in Mifos. We want it to be easier and faster to do front end (user interface) work in Mifos. The idea of this project is to prototype a completely new implementation of the Mifos user interface (UI). The goal is that the UI should look the same as the current user interface, but use Groovy, Grails, GSP pages and HTML based on CSS and the Blueprint CSS framework.

• this is a big project that multiple people will be able to work on together
• the main goal is to recreate the look and feel, and page flow of Mifos in a stand alone Grails application. This is a prototype that is not intended to include any functionality or use business logic or connect to a database. We will develop a stubbed out or "dummy" service for each web page or set of web pages that will provide static data that can be used to populate the page.
• goals include:
  • creating HTML pages that use the Blueprint CSS framework instead of tables for page layout.
  • keeping the HTML pages as simple and clean as possible by using CSS
  • using Grails webflow to implement multiple page flows like client creation
  • finding a way to run the Mifos acceptance test suite on the prototype to validate that HTML page elements and page flows match the real application
  • pay attention to localized input and output for dates and numbers
  • use GSP templating to reuse code (avoid Groovy in GSP pages and avoid custom tag libraries)

See PrototypeMifosWithACSSFramework for background on using a CSS framework

Internationalization/Localization Improvement

Mentor: Adam Monsen (Unlicensed)

This project involves Java and JSP coding. Spoken/written knowledge of languages other than English is not required.

• Make Localization easier
  • resolve issue 2820
  • resolve issue 2018
  • resolve issue 2034
  • resolve issue 2302
  • resolve issue 2350
  • eliminate duplicate strings
  • eliminate unused strings
  • remove all HTML markup from strings
    • HTML in strings limits their usage
    • this confuses our online translation tool
  • Resources.properties appears to have duplicate strings found elsewhere in the application. Refactor code and remove this file, if possible.
  • collect all translated strings into a single string bundle (this will be easier to do after migrating off of struts-- I'd vote to defer -Van)
  • remove use of custom string customization mechanism ("Admin" -> "define labels") in favor of a tested, documented approach using Java .properties string bundles to override translated strings
• Implement internationalized date handling in Mifos
  • get Mifos to accept date input and display dates using the locale that has been selected for Mifos. This means using the correct month, day, year ordering and correct date separator ("/", ".", etc.)
• Implement internationalized numeric handling in Mifos
  • get Mifos to accept numeric input and display numbers using the locale that has been selected for Mifos. This means the correct decimal separator ("." or "," or...) for the locale should be used when parsing or printing numbers.

Expand and enhance automated acceptance test suite

Mentor: Jeff Brewster (Unlicensed)

This is a fun project for someone excited about learning more about open source testing and eager to deliver iterative improvements. We have an automated test acceptance test suite which drives our user interface using Selenium RC. We need to expand our test coverage to better test areas of Mifos that are critical to our customers and their clients. Creating new tests require understanding the application's business requirements, learning the acceptance test framework, definition of test cases, and developing those tests in Java.

• In addition to writing new acceptance tests, we also need to enhance this test suite. Enhancements may include:
  • improve and simplify the current mechanism for managing test data.
  • better error logging when tests fail
  • develop method to run sets of tests under various Mifos configuration settings.
  • language-independent acceptance tests
  • generating test-specific data during test setup

Speed up unit and integration automated test suite

Mentor: UdaiU (Unlicensed)

Mifos build takes around 40 mins on a regular development machine. The integration tests takes around 20 mins (for a 40 mins build). We would like to reduce the time taken by integration tests as it will:

1. Increasing developer productivity, A fast test suite leaves more time for the developer to write code.
2. Reducing the chance of introducing bugs, A fast test suite will be run more often so bugs will be caught sooner.
3. Make identifying and fixing problems more efficient.

This project would involve:

• Converting integration tests to unit tests. There is no list for these integration tests. Student would have to identify which one can be refactored.
• Create new unit tests
• Remove unneeded/duplicate tests
• Extract unit tests from integration tests and make it a real integration test.
• Improve test framework for future maintenance and expansion.
• using the mockito mocking framework to write unit tests
• migrate from TestObjectFactory integration test usage to use the builder pattern to create objects for tests
  • curb constructor proliferation

Additional and optional scope, Migrate to TestNG framework (After above tasks are complete)

Database upgrades using LiquiBase

Mentor: Adam Monsen (Unlicensed)

LiquiBase is a database-independent library for tracking, managing and applying database changes in a more controlled and flexible way. http://www.liquibase.org

Currently, a homegrown database upgrade mechanism handles schema and initial data changes in Mifos.

We're expecting LiquiBase to solve problems such as:

• Merging changes from multiple developers
• Code branches
• Managing production data as well as various test datasets
• Cluster-safe database upgrades
• Automated updates or generation of SQL scripts that can be approved and applied by a DBA
• Update rollbacks
• Database "diff"s
• Generating starting change logs from existing databases
• Generating database change documentation

see these Java classes in Mifos source control to know how the homegrown upgrade mechanism is working:

• DatabaseVersionPersistence
• LatestTestAfterCheckpointIntegrationTest

Spring managed Entity Persistence and Transactions

Mentor: UdaiU (Unlicensed)

Mifos currently has a legacy hibernate (static util 2.0) transaction management code.

This is a challenging and risky project. Student should be very experienced with or able to rapidly learn Hibernate, Spring (Transaction and Mapping)

• Use Spring Transaction Management for all transactions
• remove use of static HibernateUtil class and use Spring HibernateTemplate
• Integration tests should be able to rollback in a tearDown (after test or after class) method
• Abolish the "big hammer" from integration tests
  • Currently, the "big hammer" (TestDatabase#resetMySQLDatabase) is used in many places in the integration tests (tests that hit the database) to break test inter-dependencies. Make each integration test run within a single transaction that is rolled back.
  • This requires a good deal of fixing the way Mifos currently handles transactions since commits are littered throughout the layers of back-end code.

Additional and optional scope, Move to JPA 2.0 model from Hibernate. (will be considered only after completion of above tasks).

• This will be simple after achieving the above state.
• Replace the Hibernate xml mappings to JPA annotations.
• Replace use of Spring HibernateTemplate to Spring JPATemplate
• Change Named Queries to JPA 2.0 Criteria queries

Increase Mifos Modularity By Refactoring Business Objects Out Of Mifos UI Layer

Mentor: johnwoodlock (Unlicensed)

This is part of the architectural work described in Evolving the Mifos Code Base. Mifos currently uses Struts and JSPs to implement the UI Layer. The UI Layer contains a significant amount of domain logic and business objects access. In order to 'modularise' mifos there is a need to refactor the domain logic and business objects out of the web UI and deliver data transfer objects via services instead.

This work will be important to other people who will be looking at new UI implementations and those who are looking to improve Mifos scalability. Refactoring UI And Service Interaction shows a draft of the refactoring design.

Read more about the approach and what struts actions to refactor in How To Refactor Struts Action Classes To Service Facade Pattern.

Custom Fantastic Mifos Project

Is there something missing from this ideas list that you want to do? Let us know! Send your project proposal(s) to the developer mailing list.

Timeline

Official GSoC 2010 timeline

See Also

• SoC FAQ
• Application Template