Codable — the Swift way

Content posted here with the permission of the author Shirish Bankar, who is currently employed at Josh Software. Original post available here

We have always spent hefty amount of time to parse and format a JSON response to our views and same amount of time again to collect data from there and create a JSON key by key to post to server. It was the traditional way until Apple gave us JSON Codable protocol at WWDC with Swift 4. An elegant way to parse and create JSON to and from models equivalent to the JSON hierarchy.

Swift Codable protocol has offered following things to us :

  • Using Codable, we can model JSONObject or PropertyList file into equivalent Struct or Classes by writing very few lines of code. We don’t have to write the constructor for the properties in the objects. It’s all handed by Codable. We just need to extend our model to conform to the Codable, Decodable or Encodable protocol.
  • Mismatch between the strong data types of Swift and loose data types of JSON has been internally handled by Swift compiler. We can now handle Swift Data types like Date, URL, Float etc
  • Complex JSON can be modelled easily using Nesting Structs for readability.
  • Parsing actual JSON become one-liner using JSONDecoder

For instance we’ll use below JSON :

{
  “username”: “shirish@joshsoftware.com”,
  “id”: 628593,
  “profile_image”: “https: //josh.intranet.com/shirish21790.jpeg", 
  “designation”: “senior ios developer”, 
  “name”: “Shirish Bankar”, 
  “company”:” [“Deskera”, “MangoApps”, “Josh software”]”, 
  “personal_info” : {
  “dob”:”21–07–1990",
  ”blood_group”: ”bpositive”,
  ”marital_status”: ”married”,
  ”contact”: ”8669005821" 
  }
}

Now to parse this JSON we’ll create following struct.

struct EmployeeInfo {
 let username: String?
 let designation: String?
 let id: Int?
 let profile_image: URL?
 let company: [String]?
 let personal_info : PersonalInfo? 
}

Here profile_image is of URL type in our struct and in JSON its a string. Now conforming to Codable protocol will take care of this type mismatch. Here we also have a type PersonalInfo which will become another struct to create a hierarchy and conforming it to Codable will parse data into it too along with EmployeeInfo. Also, notice few constants are declared as camel case which is not Swift standard convention. To take care of camel case we declare CodingKeys enum and tell to use snake case for Swift constant and camel case for JSON. Our final struct will be like :

struct EmployeeInfo: Codable {

    let username: String?
    let designation: String?
    let id: Int?
    let profileImageUrl: URL?
    let company: [String]?
    let personal_info : PersonalInfo?
    
    private enum CodingKeys: String, CodingKey {
        case username 
        case designation
        case id
        case profileImageUrl = "profile_image”
        case avatarUrl = "avatar_url”
        case company
        case personalInfo = "personal_info"
    }
}

Parsing JSON with Codable

guard let apiUrl = URL(string: "https://api.getMyJSON/shirishInfo?") else {
    return
}

URLSession.shared.dataTask(with: apiUrl) {
    (data, response, error) in guard let data = data else{return}

    do {
        let decoder = JSONDecoder()
        let myData = try decoder.decode(EmployeeInfo.self, from: data)
        print(myData.username)
    } catch let err {
        print(“Err”, err)
    } 
}.resume()

We have parsed our JSON data (supposedly) received from the api url. We can access all properties using myData variable.

Now the reverse procedure :-

Creating JSON from your struct :

let encoder = JSONEncoder()encoder.outputFormatting = .prettyPrintedlet data = try encoder.encode(myData)print(String(data: data, encoding: .utf8)!) 
//** This is our json **//

Thats it we can use JSONEncoder to create JSON to be sent to server this easily . So this is the real magic behind Codable .

Learnings from first solo talk at RubyConf TH

Content posted here with the permission of the author Shweta kale, who is currently employed at Josh Software. Original post available here

I spoke at International RubyConf alone for the first time and it is one of the best experience I ever had at a conference.

It all started few years back when I joined Josh. We had to deliver internal talk and I realised my biggest fear is Public Speaking. I decided to overcome this fear therefore I delivered two talks at RubyConf, first was lightening talk and second talk with a colleague. Now I wanted to move ahead and give solo talk!

I submitted CFP at few of the conferences but it didn’t get selected. I thought it’s not my cup of tea but every time I attend conference the question I used to get from my dad was when are you going to speak at conference? At Josh Software we had a great session on Goal Setting early this year and we all were asked to publish our Goals on internal channel. One of my Goal was to speak at conference and take my parents along with me. Publishing your Goals in your team really helps. Once you publish the Goal you work towards achieving them! I have already achieved 50% of the goals which are supposed to be completed in next 5 years.

In this blog post I will highlight few of the learnings from my first solo talk!

Practise your talk in front of mirror

When you practise your talk in front of mirror you realise what needs to be improved! So always practise your talk in front of mirror.

Record your talk while practising

Recording helps you to analyse your talk on your own! I had recorded my talks 10 times and when I listen first recording and last recoding it had improved a LOT.

Time your talk

Time your talk so you can add/remove few points if required.

Have presenter notes ready

All the tools has facility of presenter notes and when you present your talk you can see those notes on your screen.Those notes are there to give you confidence. I was always worried what if I get blank on the stage? But after adding notes I was bit relaxed as I had feeling that there will be some one who will remind me if I get blank. Though I didn’t use these notes at conference but surely it boosted my confidence!

Check license of the image before you use it

We always tend to add images in our slides because it makes easy to keep audience in sync. But few images are not allowed to be used so always check licence of the image before you use it. Your talk gets recorded so never forget this.

Talk slowly

Talk you are going to deliver is new for most of the people in audience. Audience take some time to figure out what you are talking so talk slowly and repeat your important points twice.

Never read the slides

If you read the slides you loose attention of the audience so never read your slides. Your slides should have highlighted points only. If your slides has more content, audience will start reading it which will distract them.

Look at the audience when you talk

This helps keeping audience engaged in your talk rather than phone 

Make friends before conference start so you have few known faces in the audience

At the time of RubyConf TH There was a cruise dinner arranged at chao phraya river. It was a excellent idea as all speakers got chance to interact with. I knew few of them from DeccanRuby Conf and RubyConf India but many of them were new faces to me but throughout the cruise I didn’t feel like I am new here. Thanks to awesome ruby community. Made some #rubyfriends during this party 

Because of this I had few known faces in the audience which helped me for my own moral support.

Have some punch in first 3 minutes of your talk.

It helps you to get comfortable on stage. In my talk I didn’t have many punches. But when I started the demo of my talk there was laughter and claps from audience at one place. Which gave me some time to cool down and made me comfortable on stage.

Give demo of your talk in front of group of people you are comfortable with, for example meetup

I had given demo of my talk to Josh team. I got really good feedback/ tips from the team also got confidence.

Have backup plan if your laptop crashes

I was all set for my talk and just before I travel my laptop crashed And Apple store said it will take 3-5 days to diagnose the issue. So I had to recreate my presentation. I managed to do it in time. So always keep back up plan ready! Mail slides and PDF to your self and keep it in pen drive.

If you have fear of public speaking start with lightening talk

Many of the conferences has concept of lightening talks. This is a great stage to start with. You get chance to speak in front of many people. Also these talks get recorded. So you can see video later and Enjoy your talk. Also you get chance to learn from mistakes you have made! I had delivered my first lightening talk at DeccanRuby Conf. Timing for these talks are from 3 to 5 minutes.

Don’t give up if talk is not selected

Yes it happens. My 7-8 CFP’s got rejected (different topics) before this selection. But in every conference there are 100’s of CFPs and selection committee has to choose around 10% of the CFPs. There are chances that similar talk was delivered in earlier edition of the conference or there are few better topics than your. So never get disappointed if talk is not selected. Keep trying another conference might be waiting for you!

Submit same talk at multiple conferences

If your talk does not get selected at one conference, it might get selected in other one. I met one person at DeccanRuby Conf whose CFP was not selected at RubyConf TH but got selected in some other conference where mine was not selected. So it totally depends on what kind of topics conference demands.

My first solo talk went well. A lot of people came up to me to say that they liked the talk. It was all very overwhelming. Here are photos with all the attendees.

It was an amazing conference. This was first edition of RubyConf TH – Awesome venue, amazing people, cruise party. Kudos to organisers and volunteers for pulling this off.

You can find slides of the talk here.

Big thanks to Josh team for valuable feedback and conference budget 

🙂

Data Race Detector in Golang

Content written by author Rahul Shewale, who is currently employed at Josh Software.

As we know, Golang is a powerful programming language with built-in concurrency. We can concurrently execute a function with other functions by creating goroutine using go keyword. When multiple goroutines share data or variables, we can face hard to predict race conditions.

In this blog, I am covering following points

  • What is data race condition and how can it occur?
  • How can we detect race conditions?
  • Typical Data Races examples and how can we solve race conditions?

What is the data race condition?
A data race occurs when two goroutines access the same variable concur­rently, and at least one of the accesses is performing a write operation.

Following is a basic example of race condition:

package main
import (
    "fmt"
    "sync"
)
func main() {
    var wg sync.WaitGroup
    wg.Add(5)
    for i := 0; i < 5; i++ {
        go func() {
            fmt.Println(i)
            wg.Done()
        }()
    }
    wg.Wait()
 }
}


In the above example, you must have noticed we have invoked 5 goroutines and access i variable inside the goroutine, but here we faced data race condition because all goroutine read data from i variable concurrently and at the same time for loop write a new value into i variable.

Program OUTPUT:

5 5 5 5 5

How can we detect race conditions?

Now that we know what is a race condition, let’s dive into how to detect these conditions on your Golang project. So Golang provides built-in powerful race detector tools for checking the possible race conditions in program.

To use the built-in race detector you need to simply add -race flag to your go run command:
$ go run -race main.go

This command finds a data race condition in the program if any and print error stack where race condition is occurring

Sample Output
$ go run -race  race_loop_counter.go

==================
WARNING: DATA RACE
Read at 0x00c0000a8020 by goroutine 7:
  main.main.func1()
      /home/-/goworkspace/src/example/race_loop_counter.go:13 +0x3c
Previous write at 0x00c0000a8020 by main goroutine:
  main.main()
      /home/-/goworkspace/src/example/race_loop_counter.go:11 +0xfc
Goroutine 7 (running) created at:
  main.main()
      /home/-/goworkspace/src/example/race_loop_counter.go:12 +0xd8
==================
==================
WARNING: DATA RACE
Read at 0x00c0000a8020 by goroutine 6:
  main.main.func1()

Goroutine 6 (running) created at:
  main.main()
      /home/-/goworkspace/src/example/race_loop_counter.go:12 +0xd8
==================
2 2 4 5 5 Found 2 data race(s)
exit status 66

How can we solve it?

Once you finally find race condition, you will be glad to know that Go offers multiple options to fix it.

Rob Pike has very aptly stated the following phrase. The solution to our problem lies in this simple statement

“Do not communicate by sharing a memory; instead, share memory by communicating.” -Rob Pike

  1. Use Channel for data sharing

Following is a simple program where the goroutine accesses a variable declared in main, increments the same and then closes the wait channel.

Meanwhile, the main thread also attempts to increment the same variable, waits for the channel to close and then prints the variable value.

However, here a race condition in generated between main and goroutine as they both are trying to increment the same variable.

Problem example:

package main
import "fmt"

func main() {
    wait := make(chan int)
    n := 0
    go func() {
        n++
        close(wait)
    }()
    n++
    <-wait
    fmt.Println(n)
}

To solve the above problem we will use the channel.

Solution:

package main
import "fmt"
func main() {
    ch := make(chan int)
    go func() {
        n := 0
        n++
        ch <- n
    }()
    n := <-ch
    n++
    fmt.Println(n)
}

Here the goroutine incrementing the variable and variable value pass through the channel to main function and when channel receives data then main perform next operation.

2) Use sync.Mutex 

Following is a program to get the total number of even and odd numbers from an array of integers, numberCollection and store into a struct.

Following is a program to get the total number of even and odd numbers from an array of integers, numberCollection and store into a struct.

Problem example:
package main
import (
    "fmt"
    "sync"
)

type Counter struct {
    EvenCount int
    OddCount  int
}

var c Counter
func main() {
    numberCollection := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
    fmt.Println("Start Goroutine")
    var wg sync.WaitGroup
    wg.Add(11)
    for _, number := range numberCollection {
        go setCounter(&wg, number)
    }
    wg.Wait()
    fmt.Printf("Total Event Number is %v and Odd Number is %v\n", c.EvenCount, c.OddCount)
}
func setCounter(wg *sync.WaitGroup, number int) {
    defer wg.Done()
    if number%2 == 0 {
        c.EvenCount++
        return 
    }
         c.OddCount++
    
}

Output:

 Total Event Number is 5 and Odd Number is 6

If program is checked by race detector flag then we notice line  c.EvenCount++  and line no 31  c.OddCount++ generate race condition because all goroutine writes data into struct object concurrently.

Solution:

To solve this problem, we can use sync.Mutex to lock access to the struct object as in the following example:

package main

import (
    "fmt"
    "sync"
)

type Counter struct {
    EvenCount int
    OddCount  int
    mux       sync.Mutex
}

var c Counter

func main() {
    numberCollection := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
    fmt.Println("Start Goroutine")
    var wg sync.WaitGroup
    wg.Add(11)
    for _, number := range numberCollection {
        go setCounter(&wg, number)
    }
    wg.Wait()
    fmt.Printf("Total Event Number is %v and Odd Number is %v\n", c.EvenCount, c.OddCount)
}
func setCounter(wg *sync.WaitGroup, number int) {
    defer wg.Done()
    c.mux.Lock()
    defer c.mux.Unlock()
    if number%2 == 0 {
        c.EvenCount++
 return 
    } 
        c.OddCount++
   }

3) Making Copy of variable if Possible 

Problem example:
package main
import (
    "fmt"
    "sync"
)
func main() {
    var wg sync.WaitGroup
    wg.Add(5)
    for i := 0; i < 5; i++ {
        go func() {
            fmt.Printf("%v ", i)
            wg.Done()
        }()
    }
    wg.Wait()
}

In the above problem, we can see five goroutines invoked in for loop and access value of i  from the goroutine. Every Goroutine is called asynchronously and goes to wait state until the for loop is completed or any block operation is created.

After for loop execution is completed all goroutine will start execution and try to access i variable. This will result in a race condition.

For this problem,  we can easily pass copy argument to goroutine and every goroutine gets a copy of the variable. As shown in the example, below we use argument j instead of accessing i from within goroutine.

Solution :

package main
import (
    "fmt"
    "sync"
)
func main() {
    var wg sync.WaitGroup
    wg.Add(5)
    for i := 0; i < 5; i++ {
        go func(j int) {
            fmt.Printf("%v ", j)
            wg.Done()
        }(i)
    }
    wg.Wait()
}

Conclusion:
The preferred way to handle concurrent data access in Go is to use a channel and use -race flag for generating data race report, which helps to avoid a race condition.

%d bloggers like this: