This week in review: Moveit! system design

~more>

Generate your own contribution graph at https://github-contributions.vercel.app/

I created my github account almost 10 years go in March of 2013. I was in India until mid 2016. I mainly used github for my personal website (github pages) and some Kaggle stuff until this point.

August of 2016, I moved to Utah for grad school. I worked at LL4MA Lab and we mainly used Bitbucket. Because of that my github is mostly dormant during this period. I became active in 2017 for a brief moment, I think this was the year I worked on a bunch of side projects and assignments that I wanted to show off. I quickly got distracted from this though.

2018 was when I graduated and started searching for jobs. I joined 42 Silicon Valley while searching for jobs. I was still very undecided if I wanted to do a PhD or go into the industry. I still think about this, if it was the right choice or not.

I was very active between 2019 and 2020. This was when I worked at Omron and had a very good work life balance. My contributions tanked once we were fully in lockdown. I got really into fitness and biking in particular. I did may 100+ km rides on my bike during this time.

I switched jobs from Omron to Nimble in May of 2021. Work took over most of my time at this point in my life. Any contributions here were related to stuff I was working on at Nimble.

Early 2022 I got very intestedted in generative art. I worked on creating lot of stuff using processing. I had a lot of fun doing this. While I stopped posting things publicly, I worked on making quite a few goofy animations that will probably never be public.

curl https://api.github.com/users/hashb

{
  "login": "hashb",
  "id": 3821043,
  "node_id": "MDQ6VXNlcjM4MjEwNDM=",
  "avatar_url": "https://avatars.githubusercontent.com/u/3821043?v=4",
  "gravatar_id": "",
  "url": "https://api.github.com/users/hashb",
  "html_url": "https://github.com/hashb",
  "followers_url": "https://api.github.com/users/hashb/followers",
  "following_url": "https://api.github.com/users/hashb/following{/other_user}",
  "gists_url": "https://api.github.com/users/hashb/gists{/gist_id}",
  "starred_url": "https://api.github.com/users/hashb/starred{/owner}{/repo}",
  "subscriptions_url": "https://api.github.com/users/hashb/subscriptions",
  "organizations_url": "https://api.github.com/users/hashb/orgs",
  "repos_url": "https://api.github.com/users/hashb/repos",
  "events_url": "https://api.github.com/users/hashb/events{/privacy}",
  "received_events_url": "https://api.github.com/users/hashb/received_events",
  "type": "User",
  "site_admin": false,
  "name": "Chenna Kautilya",
  "company": null,
  "blog": "https://chenna.me/",
  "location": "San Francisco , CA",
  "email": null,
  "hireable": true,
  "bio": "I like robots.",
  "twitter_username": "kautilyach",
  "public_repos": 76,
  "public_gists": 11,
  "followers": 17,
  "following": 59,
  "created_at": "2013-03-10T02:15:01Z",
  "updated_at": "2022-12-07T22:31:35Z"
}

I was discussing with a friend earlier today about the need for pattern matching and I remembered this particular blog that I read few years ago.

• Pattern matches can act upon ints, floats, strings and other types as well as objects. Method dispatch requires an object.
• Pattern matches can act upon several different values simultaneously: parallel pattern matching. Method dispatch is limited to the single this case in mainstream languages. -Patterns can be nested, allowing dispatch over trees of arbitrary depth. Method dispatch is limited to the non-nested case.
• Or-patterns allow subpatterns to be shared. Method dispatch only allows sharing when methods are from classes that happen to share a base class. Otherwise you must manually factor out the commonality into a separate member (giving it a name) and then manually insert calls from all appropriate places to this superfluous function.
• Pattern matching provides exhaustiveness and redundancy checking which catches many errors and is particularly useful when types evolve during development. Object orientation provides exhaustiveness checking (interface implementations must implement all members) but not redundancy checking.
• Non-trivial parallel pattern matches are optimized for you by the F# compiler. Method dispatch does not convey enough information to the compiler’s optimizer so comparable performance can only be achieved in other mainstream languages by painstakingly optimizing the decision tree by hand, resulting in unmaintainable code.
• Active patterns allow you to inject custom dispatch semantics.

Many years ago, back when I was interested compiler design, I briefly worked on F# in an academic setting. I am not sure if anyone uses F# in production but it is a very interesting langauage. I learned a lot about Hindley-Milner type inference, monads, pattern matching and more. Surprisingly I learned about functional programming features from F#.

I recently got more serious about learning rust and have noticed a lot of similarities between the two languages. One major difference is F# is garbage collected (because of C# base). F# is also a lot more forgiving than rust imo.