If Condition

If uses locial and comparasion to evaluate an expression and code is executed based on the result of the expression. The result of these expression is a boolean. Boolean data type and logical operators available for them was covered in part 2 of kotlin basics. Before getting into the if else expressions, lets look at the logical and comparision operators in Kotlin.

    val x = 3
    val y  = 5
    val z = 8
    println(x == y) //false
    println(x + y == z) //true
    println(x > 5) //false
    println(x < 5) //true

An if statement starts with the if keyword followed by a condition, which is a boolean expression inside parentheses and a set of curly braces which contains a block of code. The block of code only execute when the condition is met.

    val x = 10
    if (x % 2 == 0){ // % is used to find remainder
        println("$x is an even number")
    }

We can also execute a block of statement if the value is false using the else keyword. The else branch in an if/else conditional only gets executed when all previous branches return false values.

    fun maxOf(a: Int, b: Int): Int {
        if (a > b) {
            return a
        } else {
            return b
        }
    }

    fun main() {
        println("${maxOf(3, 5)}") // 5
        println("${maxOf(8, 6)}") // 8
    }

We can also have multiple conditions using the else if keyword. Subsequent else if branches in an if/else conditional will get executed only when previous if or else if branches return false values.

    fun trafficLights(color: String) {
        if (color == "red") {
            println("Stop")
        } else if (color == "yellow") {
            println("Slow")
        } else if (color == "green") {
            println("Go")
        } else {
            println("Invalid Color")
        }
    }

    fun main() {
        trafficLights("red") //Stop
        trafficLights("green") //Go
        trafficLights("black") //Invalid Color
    }

When Condition

If there are a lot of conditions the code might difficult to read and write with the if/else condition. It is recommended to use the when conditional to replace an if/else conditional when there are more than two branches. When is similar to switch statements in other languages.

    fun printObjectType(myData: Any){
        when(myData) {
            is String -> println("String")
            is Int -> println("Integer")
            is Boolean -> println("Boolean")
            else -> println("Unknown")
        }
    }

    fun main() {
        
    }

There are two new things in this example. The Any data type and the is operator. Any data type is a special type in Kotlin from which all other type and object are derived. This means the function printObjectType can take anything as an argument.

The is keyword allows to check the type of an object. When conditionals also support few other ways to make descisions in the code. You can write more complex conditions in when conditionals with the comma (,), in ranges, and the is keyword.

    val x = 3
    when (x) {
        2, 3, 5, 7 -> println("x is a prime number between 1 and 10.")
        in 1..10 -> println("x is a number between 1 and 10, but not a prime number.")
        else -> println("x isn't a prime number between 1 and 10.")
    }

Creating Custom Functions

A function definition starts with the fun keyword, followed by the name of the function, a set of opening and closing parentheses, and a set of opening and closing curly braces. Contained in curly braces is the code that will run when the function is called.

    fun hello() {
        return println("Hello, world!")
    }

    fun main() {
        hello()
        // Hello, world!
    }

Declaring Parameters

A parameter specifies the name of a variable and a data type that you can pass into a function as data to be accessed inside the function. Parameters are declared within the parentheses after the function name. Each parameter consists of a variable name and data type, separated by a colon and a space. Multiple parameters are separated by a comma.

    fun hello(name: String, age: Int) {
        println("Hello, $name!, you are $age years old")
    }

    fun main() {
        hello("Nirab",25)
        // Hello, Nirab!, you are 25 years old
    }

Parameters in Kotlin are immutable. You cannot reassign the value of a parameter from within the function body.

Returning Value

Kotlin functions can also send back values which can be stored in a variable that you can use elsewhere in your code. When defining a function, you can specify the data type of the value you want it to return. The return type is specified by placing a colon (:) after the parentheses, and then the name of the type (Int, String, etc).

    fun multiply(x: Int, y: Int): Int {
        return x + y
    }

    fun main() {
        val result = multiply(10, 5)
        println(result)
        // 50
    }

By default, if you don’t specify a return type, the default return type is Unit. Unit means the function doesn’t return a value. Unit is equivalent to void return type in Java and C; and None in Python.

Named and Default Arguments

You can name one or more of a function’s arguments when calling it. This can be helpful when a function has many arguments or when you dont know the order of the parameters in a function.

    fun hello(name: String, age: Int) {
        println("Hello, $name!, you are $age years old")
    }

    fun main() {
        hello(age=25, name="Nirab") 
        // Order does not matter when you name arguments
    }

Function parameters can also specify default arguments. When you call a function, you can choose to omit arguments for which there is a default, in which case, the default is used.

    fun hello(name: String = "Mr X", age: Int = 50) {
        println("Hello, $name!, you are $age years old")
    }

    fun main() {
        hello("Nirab",25)
        // Hello, Nirab!, you are 25 years old

        hello("Nirab")
        // Hello, Nirab!, you are 50 years old
        
        hello(age = 25)
        // Hello, Mr X!, you are 25 years old
        
        hello()
        // Hello, Mr X!, you are 50 years old 
    }

Taking User Input

The readln() function reads from the standard input. This function reads the entire line the user enters as a string.

    println("Enter something:")

    // Reads and stores the user input. For example: Hello Kotlin
    val yourWord = readln()

    print("You entered: ")
    print(yourWord)
    // Prints You entered: Hello Kotlin

Basic Data Types

Numbers

Kotlin supports different number types, such as Int, Long, Double, and Float. Int and Float are 32 bits in size, while Long and Double are 64 bits, allowing for a larger range of values.

    val myInt = 1
    val myLong = 10L
    val myFloat = 4.20f
    val myDouble = 3.14

As with other languages, Kotlin uses +, -, *, /, and % for addition, subtraction, multiplication, division, and remainder, respectively. Kotlin allows the use of underscores with the numbers for better redability.

    println(1 + 2)
    println(2_500_000_000L - 1L)
    println(3.14 * 2.71)
    println(10.0 / 3)

Division between integers always returns an integer. Any fractional part is discarded. To return a floating-point type, at least one of the arguments needs to be a floating-point.

    val intTwo = 2
    val intFive = 5
    val floatFive = 5.0
    println(intFive/intTwo) // Prints 2
    println(floatFive/intTwo) // Prints 2.5

Kotlin keeps numbers as primitives, but it lets you call methods on numbers as if they were objects.

    5.times(3)
    6.5.plus(4)
    8.minus(5)
    24.div(6)

String

Strings in Kotlin are similar to strings in other programming languages. Use “ for strings and ‘ for single characters. Concatenate strings with the + operator.

    val fName: String = "Nirab"
    val lName = "Pudasaini"
    val spaceBar = ' '
    val fullName = fName + spaceBar + lName
    println(fullName) //Nirab Pudasaini

You can create string templates by combining them with values; the $variableName is replaced with the text representing the value. This is called variable interpolation. You can also do mathematical operations inside strings using string templates.

    val numberOfApples = 5
    val numberOfMangos = 3
    println("You have $numberOfApples apples and $numberOfMangos mangos.")
    // You have 5 apples and 3 mangos.
    println("You have ${numberOfApples + numberOfMangos} Fruits in total.")
    // You have 8 Fruits in total.

Special characters start from an escaping backslash \. The following escape sequences are supported:

• \t – tab
• \b – backspace
• \n – new line (LF)
• \r – carriage return (CR)
• \’ – single quotation mark
• \” – double quotation mark
• \\ – backslash
• $ – dollar sign

    println('\n') // Prints an extra newline character
    println('\$') // Print the character $

Kotlin also supports multiline strings which can contain newlines and arbitrary text. It is delimited by a triple quote (“””) and does not require escaping and can contain newlines and any other characters.

    val text = """
        A quick brown fox
        jumped over a lazy fox
    """

Booleans

The Boolean type represents boolean objects that can have two values: true and false. Built-in operations on booleans include:

• – disjunction (logical OR)

• && – conjunction (logical AND)
• ! – negation (logical NOT)

    val myTrue: Boolean = true
    val myFalse: Boolean = false
    val boolNull: Boolean? = null

    println(myTrue || myFalse)
    // true
    println(myTrue && myFalse)
    // false
    println(!myTrue)
    // false
    println(boolNull)
    // null

Arrays

An array is a data structure that holds a fixed number of values of the same type or its subtypes. You can declare an array using arrayOf() function without a type associated to its elements. You can also declare arrays of integers using intArrayOf(). You can use the joinToString to print out the elements of an array.

    val momo = arrayOf("steamed", "fried", "kothe", "chilly")
    println(momo.joinToString())

    val sevenDaysOfMomoPlates = intArrayOf(2,0,1,2,2,3,1)

In Kotlin, arrays are immutable, which means once you create an array, the size is fixed. You can’t add or remove elements, except by copying to a new array which makes it very innefficient.

    var momo = arrayOf("steamed", "fried", "kothe", "chilly")
    // Using the += assignment operation creates a new array momo,
    // copies over the original elements and adds "jhol"
    momo += "jhol"

    println(momo.joinToString()) // steamed, fried, kothe, chilly, jhol

Two arrays can be added with a + operator. Arrays are indexed starting with zero and you can use square bracket with a number to access or modify the nth element.

    val order1 = arrayOf(2, "fried")
    val order2 = arrayOf(1, "kothe")

    val kitchenQueue = order1 + order2
    println(kitchenQueue.joinToString())

    println(kitchenQueue[0]) //2
    println(kitchenQueue[3]) //kothe

    kitchenQueue[1] = "steamed"

Array can also be nested to create multidimensional arrays.

    val order1 = arrayOf(2, "fried")
    val order2 = arrayOf(1, "kothe")
    val kitchenQueue = arrayOf(order1,order2)
    println(kitchenQueue[0].joinToString()) //2, fried
    println(kitchenQueue[0][1]) //fried

Type Check and Cast

In Kotlin, you can perform type checks to determine the type of an object at runtime. Type casts enable you to convert objects to a different type. In most cases, you don’t need to use explicit cast operators because the compiler automatically casts objects for you. However, be careful with implicit casts, as they are not always available. For example numbers are not implicitly converted to larger types and require explicit conversion.

    val l = 1L + 3 // Automatic conversion Long + Int => Long

    val i: Int = 2
    val s: String = i.toString() //Explicit conversion to String
    val f: Float = i.toFloat() //Explicit conversion to Float

Hello World!

Adhering to the tradition of learning a new programming language, lets start our journey into the Kotlin world by writing a simple hello world program.

fun main() {
    println("Hello world of Kotlin programming")
}

Kotlin programs require a main function, which is the entry point where your program starts executing. Everything you write in Kotlin is within this main function or is called from it. The code block has a single statement that prints to the console using the built-in println function. Running the above code will produce the following output:

Hello world of Kotlin programming

Variables

Variables in Kotlin can be defined using either the val or var keywords. The type of the variable is infered by Kotlin but can also be specified during decleration. Lets look at how we can use the val and var to declare varaibles.

fun main() {
    val name: String = "Nirab"
    var age = 35
    println("Hello $name, you are $age")
    
    // Assume a year passes
    age = 36
    println("Hello $name, you are now $age")

    /*
    * In Kotlin you will need to explicitly specify if you
    * want to assign null values to any variable or objects
    */

    val nullValue: Int? = null
}

Let us unpack the things going on in the above code. As you can see in the code we must declare a variable first before we can use it. In order to declare a variable , start with the val or var keyword. Then specify the variable name, data type, and initial value. For example: val count: Int = 2.

The val keyword is used to define a variable that is read-only and it’s value cannot change once it has been assigned. This is what we have done with the name vriable. The var keyword to define a variable that is mutable or changeable. In the code the variable age has been assigned value of 35 and later updated to 36. In Kotlin, it’s preferred to use val over var when possible.

Since Kotlin has type inference, we can omit the data type in the variable declaration if an initial value is provided. In the code above the type of the variable age is automatically guessed by the value 36 assigned to it. However to be clear you can specify the data type in variable decleration. Some common basic Kotlin data types include: Int, String, Boolean, Float, and Double. We look at different data types in Kotlin in part 2 of basic kotlin posts.

Additionally, the code has comments which are igonred by the compiler but can be used to provide information and to make code more redable. The comment can either be a single line comment indicated by // or a multiline comment starting with /* and ending with */.

Finally, as stated in the multiline comment, to assign null values to any variable, you need to explicitly specify it with a nullable type (e.g., Int?). Running the above code will produce the following output:

Hello Nirab, you are 35
Hello Nirab, you are now 36 
Null value is null

You can see that the name and age variable has been replaced by their assigned values in the output. This is called string template and is achived with the $ sign in front of the variables.

Important Kotlin Resources

• Official Kotlin Documentation
• Kotlin Koans - Excersise to Learn Kotlin Idioms

React Native vs Flutter vs Kotlin: Choosing My Path

When I last wrote Android apps, the primary tools were Java and XML. Kotlin was just beginning to receive support, and cross-platform solutions like React Native and Flutter were in their infancy. Now, the XML and Java approach to building Android apps is somewhat outdated, and the alternatives have matured significantly, offering compelling use cases.

Flutter appears to be a quick way to get started, with user-friendly tooling and cross-platform capabilities, provided you are willing to learn Dart. It has a very active and growing developer community and an impressive portfolio of apps built using it. React Native also offers cross-platform advantages, with the added benefit of allowing you to write code in JavaScript and TypeScript. Here’s why I chose Kotlin for my journey back into Android development.

Exploring Kotlin’s Capabalities

One of the main reason is that I would like to learn the Kotlin programming language itself. I am particularly interested in learning Kotlin because of its modern and efficient design. Kotlin offers a concise way to write readable code with significantly less boilerplate compared to Java. An appealing features of Kotlin is its null safety, which helps prevent the common null pointer exceptions prevalent in Java.

Kotlin’s language features, such as coroutines and flows, make writing asynchronous code much more manageable and less error-prone. These tools allow for the creation of asynchronous programs that are easy to read and maintain.

Additionally, Kotlin Multiplatform, although still in its early stages, promises to be a powerful tool for developing cross-platform applications. This capability could be highly beneficial in the future, allowing developers to share code across multiple platforms seamlessly.

Moreover, Kotlin’s compatibility with Java means that I can continue to use the Java libraries I am familiar with when needed, ensuring a smooth transition and integration into existing projects.

Cross Platform is Not Quite Native

As I embark on my journey to reacquaint myself with Android development, I’ve decided to focus on native development rather than cross-platform solutions. The advancements in reactive programming, modularization, and architectural design patterns have made native Android development more intuitive and powerful. Tools and frameworks such as Jetpack Compose, ViewModels, and Kotlin Flows have significantly enhanced the development experience, allowing for more efficient and maintainable code.

While cross-platform frameworks like Flutter and React Native offer the allure of writing code once and deploying it on multiple platforms, they come with their own set of trade-offs. The additional tooling, worrying about availability of plugins and larger app sizes associated with cross-platform frameworks do not align with my goals at this stage. However, I plan to update my web development skills in the future, at which point I might explore React Native.

The End Goal

One of the main reasons I am choosing to learn Kotlin is my ambition to contribute to the Maplibre Native codebase. In December 2020, a project I frequently used in my previous work switched to a non-open-source license. Maplibre Native, a fork of that project, has continued as an open-source initiative, and I am eager to contribute to its Android development efforts.

Learning Roadmap

From my initial research, I have identified mapped out a learning path that will help me transition back into Android development. I may jump between sections as needed. I will write separate posts for each learning milestone and link them here in this blog. My aim is to be comprehensive enough for these posts to serve as useful resources for anyone starting out in Android development.

Learning Basic Kotlin

First, I need to familiarize myself with writing code in Kotlin. I will go through online resources to learn Kotlin syntax and the basic concepts of programming in Kotlin.

• Basics of Kotlin - Part 1 : Variables
• Basics of Kotlin - Part 2 : Basic Data Types
• Basics of Kotlin - Part 3 : Functions
• Basics of Kotlin - Part 4 : Conditionals

Learning Jetpack Compose

The traditional method of building Android UIs with XML now has a better alternative. Jetpack Compose is the recommended way to build UIs in Android. I plan to explore Jetpack Compose by building a calculator app.

Revising Android Basics

I will revisit Android basics such as activities, fragments, intents, broadcasts, and services. This will help me understand which concepts are still relevant and also get acquainted with newer concepts like ViewModels and the Room library.

Kotlin Coroutines and Kotlin Flows

I will dive deep into two powerful Kotlin features. Kotlin Coroutines offer a way to write asynchronous code in a sequential manner, improving code readability and maintenance. Kotlin Flows enable reactive programming with streams of data.

Build and Publish Three Android Apps

I learn best through project-based work, so I plan to develop several Android apps as I progress through the learning process. Once I cover all the topics, I will write and publish a few apps to consolidate my knowledge. I have not yet decided on the specifics of these apps.

Contributing to Maplibre Native

Ultimately, my goal is to contribute to the Maplibre Native project. They are migrating their Java codebase to Kotlin, and as someone who has used the library extensively in the past, I am excited to offer my contributions. I aim to make meaningful pull requests to support this migration and help improve the library.

I’m thrilled to embark on this journey of reskilling in Android development. Stay tuned for updates as I navigate through these learning milestones and work towards contributing to the Maplibre Native project.

Feel free to follow along, share your thoughts, and join me in this exciting journey back into Android programming!

Download and Run Maperative

Download the latest version of Maperative and unzip it to a local folder. Linux users will also have to install mono. In debian based distributions we can simply do this using the command

sudo apt-get install mono-complete

We can now run the program by running the Maperative.sh script . We will need to set the file the be executable before you can run it by running the following command

chmod +x Maparative.sh

Download Historical OSM Data

Geofabrik hosts country level extracts for OSM data in various formats. You can download the data for Nepal by visiting this link. We can also download the older OSM files by clicking on the raw directory index. Let us download the data for Nepal from 2015 January first.

Create Map Tiles

Before we loading the old data and generateing the tiles, let us set bounds for the tiles. This can be done in Maperative by going to Map > Set Geometry Bounds

After the bounds are set you can see a bounding box in map if you zoom out a little the tiles will only be generated for the area within the bounds.

Now load the previously downloaded OSM data by going to File > Open Map Sources and selecting the downloaded OSM file. After the data is loaded we can see a new source added to the Map source window at bottom right.

Now click on the Web map and remove the map source by clicking the cross button. We will now have our OSM file as the only map source. Now let us generate the tiles by running the command

generate-tiles minzoom=8 maxzoom=14 tilesdir=output_folder

The command will generate tile that can be used by a web map server. We can use these tiles with Openlayers and Leaflet. Also take into consideration the processing and storage requirements while setting the maximum and minimum zoom levels. We will be generating the tiles from zoom level 8 to zoom level 14 for the selected bounds and it will take 390 MB of storage.

Make Map with Before After Slider

We have the tiles ready so we will create maps to display the tiles using leaflet and add a slider comparison control using leaflet side by side. You can check the code for leaflet side by side control at its github repo. Here is the code for before after map.

<html>
<head>
 <link rel="stylesheet" href="https://unpkg.com/leaflet@1.0.1/dist/leaflet.css" />
 <style>
    	body {
    	margin: 0;
    	padding: 0;
	}

	#map {
    	position: absolute;
    	top: 0;
    	bottom: 0;
    	width: 100%;
}
</style>
</head>
<body>
<title>
	Nepal Map Comparison
</title>
  	<script src="https://unpkg.com/leaflet@1.0.1/dist/leaflet.js"></script>
  	<script src="https://lab.digital-democracy.org/leaflet-side-by-side/leaflet-side-by-side.js"></script>
  	<div id="map"></div>
  	<script>
    	var mymap = L.map('map').setView([28.2184,83.9959], 10);
    	var oldMap = L.tileLayer('tiles/{z}/{x}/{y}.png', {
      	attribution: 'OSM Contributors',
      	minZoom: 8,
      	maxZoom: 14
    	}).addTo(mymap);
    	var newMap = L.tileLayer('http://{s}.tile.osm.org/{z}/{x}/{y}.png', {
      	attribution: 'OSM Contributors',
      	minZoom: 8,
      	maxZoom: 14
    	}).addTo(mymap);
       	L.control.sideBySide(oldMap,newMap).addTo(mymap);
</script>
</body>
<html>

You can see that this is a simple Leaflet code. We create a leaflet map object and add two tile layers to the map. One of our tile layer is current osm tile and another tile layer is the old map tiles generated from Maparative. The tile source must be specified in the format output_folder/{z}/{x}/{y}.png .

    	var oldMap = L.tileLayer('tiles/{z}/{x}/{y}.png', {
      	attribution: 'OSM Contributors',
      	minZoom: 8,
      	maxZoom: 14
    	}).addTo(mymap);

We can now open the HTML file in a browser and see the output.

Publishing Online

Github allows hosting simple sites using github pages. Create a new repo in github and push your code to a branch gh-pages. The map will now be available in the url https://your-username.github.io/repo-name**. You can learn more about github pages at https://pages.github.com.

Opening Up Government Data

Thimphu Thromde already had data sets like building footprints with building numbers and street with associated street names that they were looking to share with other agencies and general public. One main reason for this was they wanted the people to adopt the new addressing system developed by the Thromde. The import to OSM was coordinated using HOT tasking manager . The import process for building footprints and address (house number and street name) is documented in the OSM wiki.

Import would not properly work without having a robust local community. The next challenge was to build local community in Bhutan that was capable of uploading new data, verifying and validating the existing data and putting the data to innovative uses.

Local Capacity Building

We trained officials from Thimphu Thromde and other ministry of Bhutan government to collect and map data in openstreetmap using OSMtracker, fieldpapers and JOSM. They further learnt QGIS to create custom maps from OSM data and to do simple vector analysis. Over the course of four days participants learned the philosophy and theory behind OSM and different use of OSM along with the tools. Similar training was also given to undergraduate students from Royal Thimphu College. Students got a chance to learn about OpenStreetMap and also got hands on working experience with mapping in OSM platform.

It was interesting to see the excitement of the government officials regarding OSM and its utility to Bhutan. All the officials found OSM relevant to the work that their organization is doing and suggested that OSM movement in Bhutan should go beyond the capital city of Thimphu and spread to the whole country.

Sensitizing the Local Government

In order for this excitement of government officials to carry forward and become tangible it was important to sensitize the higher ranking officials of the organizations. We organized a half day sensitization workshop for these officials. We use the workshop to showcase application of OSM in various thematic areas like agriculture, governance and disaster management. Major part of the showcase was the use of OSM during and after the Nepal earthquake. The workshop was successful in sensitizing the people at policy level. Mayor of Thimphu Thromde , Kinlay Dorjee mentioned “OpenStreetMap can be a tool for Thromde to engage our citizens and connect with the Youth”.

Engaging Youth, Sustainability and Way Forward

Interesting and unique partnership between the Royal Thimphu College and Thimphu Thromde have emerged from the OSM work. Thimphu Thromde with the help of students of RTC were able to map two administrative units of the in good detail. During data collection students introduced the general public to offline maps in smartphone and the addressing system developed by Thimphu Thromde. This helped Thromde to not only collect data more efficiently but also to connect with the youth and engage the citizens. The students gained valuable knowledge about their community, the work of their local government and cutting edge technology.

In order for the community to be sustainable in longer run such partnership should be encouraged in other agencies of the government. Thimphu Thromde has already take a step forward towards this and hired three interns to carry forward the OSM work. Mapping events should be regularly organized which would allow local champions to emerge. At the same time some method of incentivizing long term mappers should be developed. The Bhutan OSM community is also moving forward with this using social media like facebook and wechat to stay in touch and support each other. The challenge now will be to maintain the excitement of the community and also bring in new members.

Agriculture is one of the most important livelihood sectors in Nepal. A substantial proportion of the rural income and employment opportunities for the Asian nation’s 210 million inhabitants come from farming. According to the 2014 World Bank report, agriculture contributed 235 billion NPR ($2 billion) to Nepal’s GDP — a whopping 34.35%. That’s not all. According to the National Sample Census of Agriculture Nepal 2011, the landlocked country has 3.8 million families involved in agriculture. And even though 83% of these families count on agriculture as their major source of income, the annual produce is not enough to feed even 60% of the families.

Ensuring effective agriculture production across the country has been a serious challenge due to high degree of spatial and temporal climate variability coupled with lack of agricultural datasets and technology. This is because many farmers use traditional practices in agriculture and there is a lack of commercialization in agriculture. Moreover, there is a lack of data on what is grown where. So, government and non-government organizations find it hard to plan changes that might prove effective. Also, the youth in Nepal today is disengaged with their community, and is looking to migrate to other countries for better opportunities.

Local knowledge and crowdsourcing

Enter Kathmandu Living Labs (KLL) — a not-for-profit technology company working on open data and open source technology to solve day-to-day problems faced by citizens in Nepal. Believing that the local knowledge and crowdsourcing play a powerful role in any society, KLL thought that the best way to gather the requisite information was by engaging the farmers, students and teachers in the community.

KLL had realized the power of OpenStreetMap (OSM) when it worked on map data for disaster resilience and preparedness in the aftermath of the April 2015 Nepal earthquake. Nepal has seen a considerable rise in OSM mapping and usage since 2012; majorly because of the growing community that formed around OSM and the increase in volunteers who joined the OSM movement. During the re-establishment efforts post the 2015 earthquake, it was realized that OSM is useful in many other geospatial operations than just disaster preparedness.

Due to its easy usage and open nature, OSM was the right choice for data mapping in the agriculture project which was backed by ICIMOD, NASA and USAID. Since crowdsourced open mapping for agriculture was a new concept, the pilot project was carried out in three villages — Bajrabarahi, Manahari and Padampur. These villages were selected based factors like existing agricultural productivity, schools, distance from the country’s capital Kathmandu, and the availability of satellite imagery in OSM.

Paluwa, an agricultural startup that connects rural agro producers to urban consumers, helped connect the KLL team with Bishnu Gautam from Magnus Software who, in turn, linked KLL with the Small Farmers Agriculture Cooperative. To motivate the farmers and help them visualize the project, a demonstration on OSM mapping of horticulture center was given.

Training sessions for farmers, youth

In OSM, attribute data are defined by a combination of key and value called tag. A single feature is associated with many types of information and can contain multiple tags. The challenge in mapping the agriculture data was defining the entire attribute data that was to be mapped. A farmers’ meet was organized to zero-in on the list of important things to be mapped. An agriculture consultant was also appointed to brush up the list. Suggestions of tags were also made for the attributes that did not have pre-existing tags.

The KLL team spent two weeks in each village during which training sessions for local farmers, youth, school students and school teachers were conducted. The training sessions covered mapping general geographic features, such as, roads, shops and rivers, as well as features specific to agriculture, such as, crop production pockets and crop cycle. Starting with the basics of mapping, the local trainees and participants were taught to explore interesting map features to characterize the village. This further helped identify OSM features based on local knowledge. For example, one of the villages, Bajrabarahi, is known for places of historical importance and has also developed new approaches to agriculture, such as, rainwater harvesting for irrigation. Putting things on the map and seeing the outcome of it slowly built the excitement and confidence of the participants.

Progress made during the training was an added motivation for the participants. KLL developed a mechanism to quantitatively review this progress via a visualization which showed daily progress at the start of the day. Group sessions were also conducted where the satellite imagery was projected. The farmers discussed and mapped crop production pockets. Another interesting exercise was pairing up younger school students with older farmers. The students taught the farmers about the technology, while the farmers taught the students about the locality and agricultural practices in their village.

A methodology was developed to train local citizens in mapping on OSM and using local knowledge to build the map itself, keeping in mind the four key pillars of food security: availability, access, utilization and stability. A majority of the OSM features were mapped by the enthused participants. A total of 3,692 POIs, 43 schools, five health facilities, 6,318 buildings, 518 km of road, 31.54 square kilometres of farmland and 31.45 km of irrigation canal were covered by the project.

Gaining spatial literacy, confidence

Farmers developed competency and confidence in using the technology, and the youth gained a better understanding of their village. Participants gained spatial literacy and discovered new things about their villages. One kiwi fruit farmer went to all the kiwi farms in the village, mapped them and collected production data. After a week of mapping one farmer mentioned, “Initially when I looked at the satellite image, I could not figure out anything. But now, after mapping a few identifiable places, I can take reference and figure out everything present in my community.”

The school students were also excited to use mobile phones and computers to create maps of their communities. They gained a deeper understanding of the geography lessons they learned in their classes. They also learned a lot about agriculture and their villages from their elders and farmers while helping them.

The KLL team also developed a website — www.khetibali.com — dedicated to providing information about the agricultural status of these villages. After seeing the overwhelming success of the project in these villages, Small Farmers Agriculture Cooperative wants to replicate the work in all 600 villages of Nepal. The work has also generated interest from the government.

In the coming days, KLL hopes to capitalize on this excitement and use open mapping knowledge to create an open geodata for the entire agriculture community of Nepal.

I wrote the post originally for geospatial world magazine and the original article can be found here.

Immediately after the earthquake, the government, local and international security forces, and international aid agencies all jumped in to try to help. However, there was a lack of coordination between these groups.

The power of an open source project like OpenStreetMap during a crisis like Nepal’s earthquake is undeniable, and I had the opportunity to see it up close and personal. I worked with the Kathmandu Living Labs team, where I observed thousands of local and international volunteers collaborating to create data and tools. Responding agencies used the team’s work to plan and execute their operations.

The philosophy of Kathmandu Living Labs is that by collaboratively building upon existing work, we will reach much further and have a far greater impact than working on problems individually and from scratch.

OpenStreetMap

An OpenStreetMap map of Kathmandu

Before the earthquake, Nepal had a strong OpenStreetMap community thanks to the work of Dr. Nama Raj Budhathoki. Budhathoki hosted mapping events with the support of major universities, youth groups, and NGOs/INGOs in the Nepali capital of Kathmandu. So before the earthquake even occurred, the city had already been densely mapped by hundreds of volunteers. And that work had started to expand beyond the capital city.

In the aftermath of the earthquake, about 8,000 local and international OpenStreetMap community members worked to create detailed map of affected areas, which first responders used for planning and mobilizing their resources. A task of this scale would not have been possible with only local mappers. Because many of these mappers were first-timers, resources like LearnOSM.org were invaluable in getting them up to speed. Coordination between thousand of mappers was done using the Humanitarian OpenStreetMap Team’s tasking manager, an open source tool that has been used in several disaster situations and is continuously being improved.

Nepal earthquake mapping in the Humanitarian OpenStreetMap Team’s tasking manager

Kathmandu Living Labs then took the open data gathered by what I like to call “digital humanitarians” through OpenStreetMap to relay needs of survivors and victims to volunteers on the ground. The responding units and organizations needed training on OpenStreetMap (which we provided) as well as custom maps for specific purposes and missions.

Ushahidi

The most powerful project the Kathmandu Living Labs team created during this time was QuakeMap.org. This platform helped people communicate their needs to responding organizations effectively. The system received 2,035 reports, out of which 978 were verified and 551 required action. Of the actionable reports, 434 reports were acted on and 309 were completely closed. Due to difficulties with feedback loops, we were not able to ascertain whether action was taken on the remaining reports.

QuakeMap.org was built on top of the open source Ushahidi framework, which was built in 2008 to map post-election violence in Kenya. Ushahidi has grown significantly since then, with customizable features and about 90,000 deployments worldwide.

Building QuakeMap.org on top of Ushahidi allowed us to quickly get the platform running. Because it is open, we were able to customize the deployment as the needs came in. Moreover, it allowed us to focus on the deployment from the outset, creating a process around dispatching requests to the appropriate responding organizations. Our volunteers were working around the clock on verifying and channeling the reports to the responding organizations. They were then actively seeking information on whether the needs in the reports were addressed and updating the status of the reports from that information.

Building similar technology from scratch would have required significant development time, which would have consumed all of the resources of our small team. Not to mention, in a crisis, you need to be able to move very quickly to respond to life-threatening needs.

Open Data Kit

Since the earthquake, Kathmandu Living Labs has been involved in many data collection projects for damage assessment, relief distribution tracking, and reconstruction monitoring. We’ve been working with the Nepali government’s Department of Archeology, Department of Education, Central Bureau of Statistics, and National Reconstruction Authority to collect damage assessments of historical sites, schools, and residential buildings. We’ve worked with other partners, like World Bank, Teliasonera, and Mercy Corps Nepal to use mobile data collection for relief and reconstruction monitoring and tracking.

We use KLL Collect, an application built on top of the open source Open Data Kit, for all of our data collection project. Open Data Kit (ODK) is a data collection platform consisting of various sets of tools to author, deploy, and manage mobile data collection. It allows easy authoring of mobile surveys that can be written in spreadsheets. The project started in 2008 and is backed by a worldwide community of developers and users.

By building on top of the existing ODK framework, we were able to add necessary features and customize the app to the project’s needs. We were able to use existing ODK server-side technologies and focus on improving the mobile app. In addition, the active community and fair amount of already existing online resources meant that we could always count on getting help when we got stuck.

The way ahead

It took us a calamity of huge scale to learn the importance of open data. After the earthquake, we saw adoption of OpenStreetMap by most agencies. Due to its level of details was used as a default map source.

There are important lessons that other countries can learn from Nepal and its adoption of open data after the earthquake. We saw the importance of building and having a capable local team. We saw that when thousands of people come together in an open ecosystem, they can accomplish in weeks what would have otherwise taken years to do. We saw that having easily deployable and open source systems in place is critical in times of crisis.

We can safely say that open data and open source projects saved numerous lives after the earthquake. We will need to invest in more of these projects in the future and create a local and self-sustaining communities around them.

I wrote the post originally for opensource.com and the original article can be found here.