Jordan Dimov

Why mobile money is no big deal

There's been a lot of buzz about mobile money for some time now.  Mostly, people seem preplexed by an apparent mystery.  How is it that this "low-tech" revolution has been so successful in places like east Africa, Pakistan and Cambodia for what seems like a decade now, yet it just doesn't seem to be catching up in Europe or the USA?  Just recently, some legislature has been making its way around Europe, and big corporations have been making some progress with this mobile money thing.  It even prompted a German politician to make the far-fetched comment that cash will soon be a thing that our children will only read about in history books.  

First of all, I'd like to reassure you that cash isn't going anywhere any time soon. Digital transactions, including mobile, can not completely replace cash, and they are not meant to.  You may not be aware of this, but even with our hugely successful banking industry, and with the Internet and electronic payments and all that... something like 80% of ALL payments in the world are still done in cash, to this day. (For a sample reference, google for "World Payment Report 2011"). While this number is _slowly_ declining, the "end of cash" is not anywhere in sight yet. In fact, it is not even on the agenda.

Cash has multiple benefits compared to non-cash payments, which have stood the test of time over the centuries. And while it is expensive to process, somewhat inconvenient to use, and disliked by many.. the benefits tremendously outweigh the disadvantages. Anonymity is probably one of the most significant benefits, as are historical and cultural bias, perceived security, the lack of fees and taxes on cash payments, etc.

Getting back to our topic, however... Mobile money as it exists and thrives in Kenya (M-Pesa), Uganda (MTN Mobile Money), and other places that traditionally lag behind technologically, has not caught up in Europe and the USA largely because there is no demand. There is no real problem to be solved. We have bank accounts here. We have credit and debit cards. We make on-line payments regularly. We have things like direct debit. I can't remember the last time I queued up to pay a bill. A good percentage of all my shopping is done from my laptop or my iPhone. Sure, there are inefficiencies and nusiances and things that can be done better, but.. no real pain to be healed, no real problem to be solved here. Moreover, in the west there has been enormous opposition from banks and credit card companies to something like mobile money (not to be confused with "mobile banking").

Mobile money is successful in Africa, because it serves a huge population of unbanked customers. It came in and it filled a big void. It also solved a big problem about the physical security of carrying cash around. And it was convenient. So it took off big time. None of these things (except maybe "convenience" to some extent) are factors here in Europe though.

In summary, while I can't deny that some form of this technology is stubornly comming our way, it isn't likely to be anything as turbulent and disruptive as what we've seen in Africa. And predictions that it will do away with cash payments or card payments are, frankly, quite ridiculous.  

 

 

Related articles

Experts wonder about mobile payment regulations

More analysts believe mobile wallets will replace cash and cards | CreditRepair.com

Mobile Payments & Banking Market: mCommerce Analysis, 2018 Forecasts in New Research Report at RnRMarketResearch.com

Visa executive says mobile banking and other financial services to expand | CreditRepair.com

Two further barriers to UK mobile money - /ht @Penrillian

Jordan's Cheese Selection for February 15, 2013

This is the fourth issue of a regular series that I started to identify interesting Python modules on the Internet that were recently uploaded or updated. Today's selection includes:

• funcy 0.3.1 by Alexander Schepanovski.  A very nice collection of tools to facilitate functional programming with Python.  One of many such packages, to be sure, but this one looks clean, somewhat comprehensive, and certainly fun to work with.  Good examples and documentation at ReadTheDocs.  The "TODO" list looks just as interesting as what's in the package already.  
• graphillion by Takeru Inoue.  This one is quite heavy on the claims.. but looks fascinating nonetheless. Graphillion is a Python library for efficient graphset operations.   Unlike existing graph tools such as NetworkX, which are designed to process just a single graph at a time, Graphilion manipulates a large set of graphs with great efficiency.  The author claims it is able to process "trillions of trillions of graphs" on a single computer.  The concept of a graphset is uncommon, but it comes along with any graph or network when you consider multiple subgraphs cut from an original graph; e.g., comparing possible driving paths on a road map, examining feasible electric flows on a power grid, or evaluating the structure of chemical reaction networks.
• datastore 0.3.4 by Juan Batiz-Benet.  A generic layer of abstraction for data store and database access. It is a simple API with the aim to enable application development in a datastore-agnostic way, allowing datastores to be swapped seamlessly without changing application code. Thus, one can leverage different datastores with different strengths without committing the application to one datastore throughout its lifetime.  In addition, grouped datastores significantly simplify interesting data access patterns (such as caching and sharding).  Currently available implementations include:  AWS S3, Git, mongodb, memcached, redis, and PyLRU cache.  The documentation is here.  

That's the good stuff for today.  More to come in the next instalment.  Traditionally, below are some other articles of interest:  

 

Related articles

Effective implementation of one-to-many relationship with Python NDB

A convenient way to preload data in development environment datastore

Prediction API: Machine Learning from Google

graph-tool. Python module for graph (networks) manipulation and display

Graph connect visualizing_your_graph

Jordan's Cheese Selection for February 14, 2013

This is the 3rd issue of my regular selection of interesting Python and Django modules that were recently uploaded or updated on PyPI (the Python Package Index).  We'll begin with a couple of updates:

• partpy by Nekroze, the collection of tools for hand-writing lexers and parsers, which I covered two days ago, has been updated to version 0.2.1.  The changelog mentions internal cleanup and refactoring, as well as added examples.  
• nameparser by Derek Gulbranson, which I also covered in the first issue of this series, has been updated to version 0.2.7.  This is a module for parsing human names into their components.  What's new in the latest version is mainly bugfixes, as well as the ability to handle legal and crown titles.  

Here's what else is noteworthy in the cheeseshop.  The focus today is on web services and REST APIs:  

• django-tastypie 0.9.12 by Daniel Lindsley.  A flexible and capable API layer for Django.  This module has been available since 2010, and while it's currently in beta, it has been actively used in production on multiple sites.  I've personally used it in several different projects and I can confirm that it's stable and gets the work done.  Allows you to easily (almost auto-magically) create an API for your Django app that is RESTful and uses HTTP well.  Good support for deep relationships.  No need to write your own serializer to make the output right.  If you are using Tastypie in a commercial environment, paid support is available from the author.  The project's Github repository can be found here.  
• slumber 0.5.3 by Donald Stufft.  Slumber is a Python library that provides a convenient, yet powerful object-oriented interface to RESTful APIs.  It acts as a wrapper around the excellent requests library and abstracts away the handling of URLs, serialization, and processing requests.  The project's website (with examples of usage) is here.  
• curling 0.2 by Andy McKay.  A REST client that wraps slumber to provide a nice interface to consume tastypie APIs in Django.  Usage is almost identical to that of slumber, but provides some convenience post-processing to make it easier to handle the returned results.  Git repository is here.  

More goodness in the next issue.  Make sure to subscribe to my Python feed.  As usual, below are some related interesting articles:  

 

Related articles

How to filter ToManyField of django-tastypie by request.user?

django-tastypie-swagger 0.0.4

Is tastypie worth the trouble? I have duplicate codes in tastypie resource and my core service.

Beginner's Guide to PyCon 2013 Part I

Solidify your Python web skills in two days at PyCon US 2013

Jordan's Cheese Selection for February 13, 2013

Continuing with the series that I started yesterday, below is today's selection of notable new or updated Python and Django modules from the Python Package Index (a.k.a. the cheeseshop):  

• bob 1.1.2 by Idiap Research Institute, Switzerland -- Bob is a free signal-processing and machine learning toolbox written in a mix of Python and C++ and designed to be both efficient and reduce development time.  The toolbox provides easy to work with functions for mathematical and signal processing, image processing, machine learning, storing and managing data (in HDF5 format), database support, and performance evaluation.  Users design database access APIs and distribute them as satellite packages. Each package contains a set of APIs and backend support files that can be used to quickly access database information such as training, evaluation data or other sophisticated requirements. The documentation is available here.  
• openexchangerates 0.0.2 by Metglobal --  a simple Python client implementation of the openexhangerates.org web services, which provide real-time exchange rates and currency conversion JSON API.  Includes lice and historical exchange rates for 161 countries.  You have to sign-up to the service on-line to receive an API key.  Free for personal use.  
• django-oscar 0.4.5 by David Winterbottom -- Oscar is an e-commerce framework for Django designed for building domain-driven sites. It is structured such that any part of the core functionality can be customised to suit the needs of your project. This allows a wide range of e-commerce requirements to be handled, from large-scale B2C sites to complex B2B sites rich in domain-specific business logic.  It was built from the ground up to make very few assumptions about your project, allowing virtually any part of the framework to be extended and customised. In this way, complex business rules can be captured in an elegant and cohesive way.  The project's homepage is here.  

More to come in the next instalment of this series.  Below are some other articles of interest:  

 

Related articles

New Year's Python Meme 2012

How to use mmap in Python

Using python with subprocess Popen

Python magic and remote APIs

Prediction API: Machine Learning from Google

Jordan's Cheese Selection for February 12, 2013

I am going to start a somewhat regular feature on this blog where I hand-pick a few of the most interesting (to me, anyway) new or updated Python and Django modules from the cheeseshop.  

For today's selection, here's what caught my eye:

• norman 0.7.1 by David Townshend -- a framework for advanced data structures in Python using a database-like approach.  Designed to make it easy and efficient to implement any data structure more complex than a 'dict'.  The structures are stored entirely in memory, and most operations on them are significantly faster than O(n), often O(log n).  The documentation is available here.  
• django-cleanup 0.1.6 by Ilya Shalyapin -- connects pre_save and post_delete signals to special functions so as to automatically deletes old (i.e. dereferenced) files for FileField, ImageField and subclasses.  Looks useful for keeping your server's filesystem clean, if you deal with loads of user-uploaded content.  Has the potential to do damage if you're using transactions that can be rolled back, but if you're not, it's just plug-and-play.  Github repository is here.   
• djorm-ext-expressions 0.4.2 by Andrey Antukh -- facilitates the use of complex SQL expressions in the Django ORM.  For cases where you need to use custom-defiend database types or search operators that are not supported by Django look-ups.  Also, when you need to make queries requiring the execution of some function in the WHERE clause.  Github repository, with documentation can be found here.  
• partpy 0.1.0 by Nekroze -- a collection of tools for hand-writing lexers and parsers in Python.  There are many parser generators but there isn't much help for those who wish to roll their own parser/lexer as counter-intuitive as that may sound. By using partpy as the base for your own parser or lexer the hope is to provide you with an environment where you can dive straight into the language design, recognition and whatever else you need to do without having to figure out how string matching should be done or most of the error handling process.  Can be compiled with Cython for extra speed.  Examples and tutorials found on Github.   
• nameparser 0.2.5 by Derek Gulbranson -- simple Python module for parsing human names into their individual components.  Over 100 unit tests with example names.  Fully customizable.  You know you've always wanted to handle names like "Rev John A. Kenneth Doe III".  Google Code homepage is here.  

Hope you find these as useful and entertaining as I do.  Subscribe to my Python feed to follow this series. Check-out some related articles below.   

Related articles

Cython 0.18

How to write a recursive descent parser?

Two Scoops of Django FAQ

Django 1.5 release candidate available

Learning Python via Django Considered Harmful

Preparing a winning CV for any IT position

The following is an excerpt from my upcoming book on getting a great-paying job in IT.  Your comments and feedback will be appreciated. 

The average resume or CV has only about thirty seconds to make an impression before it is passed over. There are many reasons for this, especially in today's economy. Most employers use low-level administrative personnel for initial resume review. Unless you are applying for a position at a small start-up (and sometimes even then), your resume will only make its way to the final decision-maker after it passes through many layers of scrutiny, some of which extremely superficial.

For that reason, your resume needs to be able to catch the attention of experts in the field and entry-level "gatekeepers" who may not be invested in the final hiring process. These gatekeepers are trained to look for certain cues and key words in your resume, and if they do not find them, it becomes that much less likely you will be considered for employment. At the same time, of course, it is also important that you reach and win over knowledgeable IT executives.

Unfortunately, you'll find enormous amounts of bad resume advice out on the Internet. Many books and websites by self-proclaimed "experts" provide advice that makes your CV look dated and stilted, or which is simply irrelevant to the IT field. Following this kind of advice tends to make your resume read like everyone else's -- running the risk it will disappear in the pile.

Modern resume writing is a blend of advertising, deep communication and career strategy decision making. It relies less on the "buzz words" and formulaic structures of the past and more on aligning your written presentation with the needs of your potential employer. Remember, successful people don't need to describe themselves using hyperbolic adjectives like passionate, innovative, driven, etc. In fact, successful people don't need to use any adjectives at all. They can just describe, hopefully in a humble way, what they've done.

As an IT professional, writing a good resume will benefit you in at least three ways:

• It will show that you have the analytical skills to discover and meet an employer's needs;
• It will help you combat the stereotype that professionals in technical fields are poor communicators;
• It will get you the interview for the position you want -- if it is planned and written well!

The goal of the resume is to compel the reader to contact you right away for an interview. However, its value goes beyond that: A good resume is a powerful marketing document that allows employers to see where your unique talents will fit best.

In the next section we will cover six basic points for writing an excellent IT resume in a modern and persuasive style.

Consolidating Python Libraries

Stealing shamelessly François-René Rideau's brilliant idea from the Lisp world (Consolidating Common Lisp Libraries), I propose we start a similar movement in the Python world.  

To participate, here's the ten point program summary:

1. Pick your favorite problem domain
2. Head over to the cheese shop and identify all libraries that address it
3. Work with various library authors
4. Pick the most promising library
5. Declare it THE library
6. Add missing features present in other libraries
7. Declare other libraries obsolete
8. Rename package to short name identifying domain
9. Invite all users to migrate to new library
10. Profit

Perhaps such an endeavour has its drawbacks and it may not even make much sense for larger projects like web frameworks etc. However, overall I feel strongly that the benefits outlined in Francois' post are worth pursuing and just as valid for Python.  

Beat the Wind Challenge: Build a robot that can win a windsurfing competition

I have created a LinkedIn mastermind brainstorming group for the "Beat the Wind Challenge".  I came up recently with the idea of a 50 million dollar prize for the first non-government team to build a humanoid robot that wins a windsurf competition, with a regular surfboard, two times in a row. 

The plan is to crowd-fund the prize via Kickstarter and/or other similar platforms. 

Sample surfing competition rules: http://www.surfusa.org/id3.html

So why windsurfing? 

For the past 5 or 6 decades, we have been building computers that are exceptionally good at numerical and symbolic computation, but close to useless at other activities that human beings find trivial. Some of the biggest challenges in robotics have been in the areas of keeping balance and achieving human-like agility in motion. While there have been many commercial and military advancements in these areas lately, we are still very far from having robots that can perform satisfactory human-like motions. 

I chose windsurfing for this challenge because it is an activity that requires the highest level of development of some uniquely human skills. While a windsurfing robot may not seem like a particularly useful thing to have, building a robot that can windsurf AT ALL will most likely require major breakthroughs in robotics, materials science, computing and engineering. Building one that can beat the best humans at it will be sure to attract enough attention as to completely warp humanity into a new era of human-machine interactions. 

If we also have a requirement that ALL designs must be released to the public under a Creative Commons license (or similar), we will contribute enormously to science and humanity.

Introduction to Modern Database Systems, Part 1: Relational Databases

In this series of introductory posts, we will look at some fundamental concpets about traditional and modern databases.  

Broadly speaking, databases are structured collections of data. They are used to store and organise data in a logical, user-friendly way, that makes this data easy to work with (given a particular set of tasks). A database traditionally lays data out in a tabular format and describes its contents with columns and rows.

A database management system (DBMS, or database management software) is a piece of software that lets you control databases by providing basic management operations, such as inserting, reading, editing and deleting data.

The concept of a database is not something new that came with computer science. Without computers, structuring data is simply a form of clerical work — think of a database like a filing cabinet. Each filing cabinet has drawers (tables) and each drawer contains folders (entries). Those folders can be indexed alphabetically, and each folder holds data on files (fields). The filing cabinet's ultimate purpose is to make it very easy and fast to find a file amongst several more; databases let you do the same digitally. Don’t worry if any of those concepts are new to you, we’ll go over them shortly.

Relational Databases

Relational databases are built on the concept of, as their name would suggest, relations. A relation is a set of entries within a database that share common attributes. Such a relation is presented in a table when the DBMS asks for it; tables are organised in columns and rows like you would see in a spreadsheet.

Database management systems for relational databases are typically called Relational Database Management Systems, or RDBMS.

When speaking about tables, object tables are often implied. An object table is a concept within relational databases which stores objects with a specifically defined type.

What this means for developers is the ability to store related data within one easily-accessible place. A very common pattern is storing user data, so let us take this as an example.

In a DBMS, you would create a table to hold user objects. You would have to define which data you wish to store along with these users. For the sake of the example, we will store first name, last name, email address and gender.

Table 1.: User data in table "users"

ID	Name	Surname	Email	Gender
1	Shawn	White	swhite@example.com	Male
2	Burton	Brown	bbrown@example.com	Male
3	Mary	Lightly	mlightly@example.com	Female

In Table 1, we store data for three different users: Shawn, Burton and Mary. You will notice an additional column to the data we stored, an incremental unique identifier. In this table, it’s what we call the Primary Key.

A primary key is a row's value that is unique throughout the entire table. Such a key gives you the ability to retrieve data about a row by just knowing its unique id. When numeric, primary keys are usually incremental, that is, every new entry added to the table gets an id that is equal to the previous id incremented by 1. A primary key only needs to be unique, it doesn't have to be an incremental integer. If uniqueness is assured, it could also be the email address.

Data types

A crucial part of databases is the type of data stored by the table. Where each column expects a certain kind of data, it is safe to assume the data type will be identical throughout the column. That is why columns define data types, often similar to those you will find in programming languages.

Different RDBMS will define different types. While those data types will not be explained here, the most common ones are listed below:

Numeric types	Byte, Smallint, Integer, Bigint, Float and Double. Decimal is also often supported.
Text types	char(n) and varchar(n) respectively define a fixed-length padded string and a variable-length limited string. text defines an unlimited string. Text types often come with added features, such as search, depending on the RDBMS and the data type itself.
Other types	Boolean, Date, Time and Datetime, Interval. Several more specific (and less common) types exist as well, such as IP addresses, XML data, or even geometrical data.

You will notice that there is no commonly accepted fundamental data type for storing money and currencies. This has caused a great deal of problems and complications in financial systems and user-facing applications. We will talk more about this issue in a separate post.

What Relations can do for You

It's easy to miss the features of SQL when you do not know them. One of the common use cases of an application developer is tying one type of data to a different type of data; linking an entry within a table to one in a separate table.

Let's take our users again and let them write books. Well, first, we need books, which means we need to create a table that will store Book objects.

CREATE TABLE books (
    id int PRIMARY KEY, 
    title varchar(128), 
    pages int, 
    author int, 
    FOREIGN KEY(author) REFERENCES users(id)
);

 

Table 2.: Pre-filled data in table "books"

ID (int)	Title (varchar(128))	Pages (int)	Author (int)
1	Life in California	316	2
2	My First Computer	45	3
3	Learning C++	4711	3
4	Living with Superpowers	680	1

Table 2 shows us four books, written by our very own users. We also now see what data type is used by each column. But why is the author an integer? Our authors already exist in a different table. So, in order not to repeat ourselves, when creating the column, we would define the author column as a foreign key, pointing to our earlier table "users". Specifically, the column ID in the users table.

By cross-referencing the two tables, we can now see that Shawn wrote a book about superpowers, Burton wrote a book about California, and Mary wrote the two educational books. Instead of storing the authors as varchars for their name, we now have access to further information about our authors. We can now know the email address of the author of each of these books, with almost no effort.

Being able to organise data this way has powerful implications for database management systems. Indeed, those systems usually provide a programming interface with a standardised syntax, called Structured Query Language, or SQL for short.  We will look at SQL in a bit more detail in the next post.  

Serving several web applications using one WSGI file

For development purposes, one of our clients needed to run two different web applications (one Django-based, one using Flask) on the same Apache Virtual Host, i.e., same domain, same port, just mounted at different entry points.  More specifically, they needed http://localhost/ to point to application App1 and http://localhost/app2/ to point to application App2.  The two applications then talk to each other via web services, but this is irrelevant to our solution.  

We use mod_wsgi to connect Apache with the two applications.  After considering several possibilities, we discovered the (not so easy to discover!) DispatcherMiddleware from the Werkzeug library.  Using this allowed us to create an elegant, flexible and reliable solution, which has worked great for the client.  We ended up with a single WSGI file, no changes to the Apache configuration, and no changes to any of the applications' code.  

Here's what that WSGI file looks like (slightly simplified):  

import os
from werkzeug.wsgi import DispatcherMiddleware
from django.core.wsgi import get_wsgi_application
import newrelic.agent
newrelic.agent.initialize('/home/projects/app1/newrelic.ini')

# This serves the Django application:
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "app1.settings")
application1 = get_wsgi_application()

# This serves the Flask application:
def application2(environ, start_response): 
    from app2.server import app
    return app(environ, start_response)application = DispatcherMiddleware(application1, {
    '/app2': application2,
    })
application = newrelic.agent.wsgi_application()(application)

Notice that we apply any additional wrappers and middlewares (like the fabulous NewRelic service, which we use for instrumentation) to the final, aggregated application object.  You can, of course, apply any app-specific middleware to the corresponding application object.  

Revision Control Systems, Part 5: Online Project Hosting Services

In this introductory series on revision control systems (a.k.a. version control systems, a.k.a. source code management systems), we've looked at the basic concepts behind SVN, Git and Mercurial.  These three are the most popular version control software systems at this time. While Subversion's popularity is declining in favour of the latter two, there are also other lesser-known VCS systems you may encounter.

Bazaar, for example (often spelled as just bzr,) is another Python-based DVCS which was made popular by Canonical -- one of the leaders of the Ubuntu project. Launchpad, their online platform for Ubuntu is open to other projects and made the VCS popular thanks to its integration with a web-based interface to Bazaar as well as its issue tracker.

Online source hosting like Launchpad's was really started by Sourceforge. It was one of the first truly popular online hosts and encouraged the open source community to grow and socialise. To this day, they provide project pages and integrate with various tools including an issue tracker, mailing lists and download space.

Unfortunately, Sourceforge did not age very well. Several large projects have moved on to more modern project-oriented hosts such as Google Code and Launchpad. Smaller teams and developers that need less setup or just want to publish some code often prefer the social coding hosts Github or Bitbucket, although several large companies such as NASA, Twitter and Facebook are also using Github to release their open source work.

Although its popularity is starting to decline, Google Code supports Subversion, Mercurial and recently, Git. In addition to VCS integration, it offers features such as a simple Wiki, an issue tracker, downloads and developer groups.

Github, however, was the first to successfully introduce the concept of social coding on the web. By creating a community revolving around open source along with tools tightly integrating with a single VCS, it made using Git both easy and fun. One of its key features is easy forking between projects, which makes it very simple for someone to make changes to an existing project and publish the changes as a fork. It is also possible to create pull requests on those changes, which makes it easy for the official developers to pull and merge the changes with the original repository.

Github announced SVN support in 2010. It is both possible to checkout a github repository with SVN and to commit and push changes to a repository through SVN.

Just like Github, Bitbucket is a Mercurial-oriented social coding website. They offer the same range of features as well as a similar interface. Bitbucket added support for Git repositories in 2011. There are several other sites like these, some that support more obscure version control software, several with business solutions as well.

Once you are familiar with the basics of the VCS of your choice, you will see that you can use it for all kinds of tasks -- from small projects you do on your own, to contributing to huge projects like the Linux kernel itself, or even for tracking configuration files. You should also try out Github and Bitbucket, especially since more and more employers are asking for your Github profile as part of the application documents. Github is free for open source projects, while Bitbucket's plans includes private repositories as well. They will both let you create as many public repositories as you want. They make working with Git or Mercurial a true pleasure, I’m sure you'll enjoy it.

While none of the articles in this introductory series is meant to be comprehensive, I will appreciate it if you point out any serious mistakes or ommisions on my part.