Thali started at the Partner Catalyst Team at Microsoft which uses a short term dev model. So we had a constant rotation of devs as they rotated on to and off the project. Later on our partner Rockwell Automation started to provide resources and as budgets have shifted so have the people working on the project.

Our longer term contributors

Marek Czyz - Marek started on 3/2016 and was with the project through 2/2017. Marek did work on just about every part of the project. He drove a lot of the work of integrating Thali with Rockwell’s TeamONE code. He also wrote up the key test app that we used to replicate problems with Thali found in TeamONE. He also did a ton of work to try and keep our CI environment going as well fixing issues with tests. While this isn’t necessarily the sexiest work it is by far amongst the most critical for keeping the project going.

Andrew Aladev - Andrew started in 7/2016 and continued through 2/2016. I used to call him the terminator because he was absolutely unstopable. Whatever the bug was, he would not stop until it was terminated. Andrew was able to track down issues through Node, Java, C, Android, JXCore, whatever. Most of his work was on our testing infrastructure (which if you know anything about Thali you will understand is one of the most complicated and most used parts of our software) as well as driving resolution to issues with Node bugs (try debugging asynchronous bugs across multiple different massive libraries like Express, PouchDB, the Thali Node code and inevitably the Thali native code). He was a force of nature on the project and his contributions are missed.

Diego Marino Monetti - Diego started with Thali in July of 2016 and continued through the early part of January 2017. His contributions were made through Janea on keeping JXcore alive. It’s hard to see his contributions because in most cases they were committed by Enrico Giordani but he worked all over the JXcore code base helping to fix a variety of bugs we found as well as helping with revamping the test framework for JXcore so we could automatically run tests on devices that weren’t jail broken.

Alexander Telegin - Alex worked on Thali from 10/21/2016 through 12/9/2016. Unfortunately a budget shift required us to shrink the team and Alex was reassigned. In his month or so on the project he focused on understanding how BLE works in iOS 10 in the background, helping us understand the actual perf of MPCF and helping with our migration to Swift 3. (Note: As of 2/28/2017 Alex is now back on the project due to another shift in budget)

Ekaterina Vasileuskaya - Katya joined us in 8/2016 and worked on Thali through 12/9/2016. The same budget shift that caused Alex Telegin to be reassigned, also resulted in Katya being reassigned. Katya worked on Android focused on a wide variety of issues including fixing bugs in our tests, fixing missing features in Android, figuring out why HTC 10 phones are such a nightmare with Bluetooth, tracking down problems with how Node used Android, figuring out (successfully!!!!) how to get BLE GATT servers to behave themselves on Android, figuring out race conditions in our native code, figuring out our actual perf on Bluetooth/Wifi/etc., understanding why Bluetooth was misbehaving and alot of other detailed, difficult work. Kayta had an especially hard job because she came onto the project and inherited a lot of existing code. So she had to figure out all these problems while digging through someone else’s code. That is never much fun but she kept at it and helped us move the ball forward.

Alexander Evsyuchenya - Alex joined Thali in mid July 2016 and left the project in early November of 2016. It was Alex who realized that the entire original approach to using Multi-Peer Connectivity Framework (MPCF) on iOS in Thali was just plain wrong. He then wrote a full proof of concept to prove that all the bugs we were working around (such as thinking that we couldn’t have multiple simultaneous MCSessions between the same peers or that we could only have a single stream between two peers in a single MCSession) existed in our code, not in iOS. He led the way with a complete re-write of our native code in Swift and didn’t leave the project until all the native code was done and passing tests all up from Swift through our Node layer.

Artyom Stepanishchev - Artyom joined the Thali project on August 1st, 2016 and left the Thali project at the end of September 2016, so he was on the project for 2 months. In that time he made 96 commits covering just about every part of our Node code. He fixed bugs. Added some features. And generally proved that he is a really great dev. In just two months he went from complete newbie to trusted collaberator.

Tomi Paananen - Tomi joined in 11/2015 and worked until 4/2016. He jumped into the pit that is known as Android radio issues. He finished up our BLE code, cleaned up our whole Android code base and hardened Bluetooth. It’s hard to properly capture how painful this work is. Tests can only be run on the device, not an emulator. So every test run takes a minimum of 5 minutes just to start and then you can count for the actual time to run the test. Tests require at least two devices so debugging is a screaming nightmare. And of course Android’s BLE and Bluetooth support are a bug ridden swamp so every time anything goes wrong you have to wonder - is it your code or did you just discover yet another Bluetooth bug? He also helped us test out ‘bro mode’ to help us deal with Android’s threat to take away MAC address information. His work was not for the faint of heart but he did it and did it on a deadline.

Shawn Cicoria - Shawn found out about the Thali effort within Microsoft and volunteered to do a tour of duty on the project. He joined in 11/2015 and finished up in 4/2016. During that time he was a force to be reckoned with. He owned a whole slew of our security issues and saved us when Nubisa went out of business. Shawn was the one who edited JXcore’s calls to OpenSSL in order to enable us to use pre-shared key mode with TLS. This required code archeology of the first order not to mention figuring out how the heck you build JXcore, something that wasn’t terribly well documented. But he did it. He then created the Salti and Salti-Admin NPM modules which provide the ACL infrastructure for Thali. He then finished up by saving us when Nubisa went out of business and we had no way to build and deploy JXcore or JXcore-Cordova. Thankfully he figured it all out and got us back up and running! My advice is that it’s worth your while to see if you can convince Shawn your project is interesting. :)

Ville Rantala - Ville joined Thali in 10/2015 and finished his assignment on 4/1/2016 so he spent 6 months working on the project. In that time he was one of the super heros of the Thali project. His super power is that he can do anything. Have an iOS issue? He’ll debug and help fix the code. Have an Android issue? No problem, more debugging and fixing code. When we lost the vendor who was hosting our CI environment he almost singlehandedly brought the environment up again and fixed a mountain of issues that kept devices from working. He reworked our test coordinator code (which manages running our tests in sync across multiple devices) to make it vastly more robust. He wrote the Wifi infrastructure code, the desktop mock of our native code interfaces as well as the Thali Mobile layer which brings WiFi and native together to present a unified interface to the rest of the Thali stack. But beyond the code he wrote he really drove quality across Thali. As the person who made our CI work he was the person who would first find problems and make sure they got filed and fixed. Because of his mastery in so many areas he could go beyond just saying ‘there is a problem’ to specifying what the exact problem was and in many cases how to fix it or at least how to reliably find it. Dev, test, PM, Ville does it all.

Juhana Ilari Sakari Koski - Juhana joined Thali at the end of January 2016 and finished his assignment on the first of April so he was only here for two months but he packed a lot into those two months. He actually started on our Android code fixing some issues with Tomi but then we transitioned him over to Node where he learned Javascript and Node and then proceeded to more or less singlehandedly write our entire Node.js based notification layer.

David Douglas - David joined the project in 6/2015 and more or less finished up in 2/2016. David took our rather sad postcard demo and made it great. Which might sound simple until you realize that he was pushing Cordova way past what it was intended for while trying to use a brand new Thali framework with an unstable build. He was essentially the first real user of Thali’s December POC and he has the scars to show for it. David also redid our website so it doesn’t suck nearly as badly as it used to. He also came up with our second Logo before we had the contest for the third logo. While I am officially listing David here as an Alumni it’s not quite true because once we get the new release of Thali up and running I’ll be going back for some time he owes us that I’ve been keeping in the bank in order to help us get the postcard demo back up and running.

Matthew Podwysocki - Matt joined Thali in 2/2015 and finished his very extended tour of duty in 2/2016. During that time he actually wrote our very first ACL infrastructure, our original replication manager and our original emitter layer as well as helped David out with web issues. But his main role for Thali was as evangelist. He built up our Twitter following and spoke about Thali at conferences everywhere on earth.

Toby Bradshaw - Toby started in July 2015 and worked through January 2016. He inherited the iOS code that Brian Lambert had written and essentially end up re-writing it. After many late nights he finally got the iOS code working with the multipeer connectivity framework better than our Android code at the time for our December proof of concept. He then attempt a herculean rewrite to incorporate a bunch of lessons we learned about how MPCF appears to actually work.

Oguz Bastemur - Oguz was not technically part of the Thali team in the sense that he didn’t work for Microsoft. But Microsoft had a contract with the company that Oguz was the CTO for, Nubisa. Thali started to work with Oguz in 4/2015 and went up right to the point where Nubisa went out of business around 1/2016. To give a sense how unbelievably good Oguz was, as soon as Nubisa went under I started the process of getting him hired at Microsoft. Oguz is the technical brains who made Node.js run on iOS and Android via his JXcore project. He was the one who got levelDB to work with JXcore on Android and iOS. He was the one who got JXcore-Cordova written and running. He was the one who designed the software and spec’d the hardware for our custom continuous integration environment. Oguz is why Thali exists as it does and we are deeply grateful.

Jukka Silvennoinen - Jukka started in 12/2014 and continued through 11/2015. When Thali was rebooted as a Cordova/Node.js project Jukka was our very first dev. His contributions included but weren’t limited to:

• Got Wifi Direct and Bluetooth working well enough to enable us to demo Thali on Android
• Wrote the first version of our JXcore/native layer
• Helped us to eventually figure out that Wifi direct wasn’t going to work right on Android
• Did the initial work on figuring out if we could use BLE instead of Wifi direct
• Helped us get the first iteration of our test infrastructure up and running

Srikanth Challa - Srikanth started at the end of 2/2015 through 8/2015. He did the work to put in support for HKDF and PKCS12 libraries directly into JXCore thus enabling new capabilities in JXCore’s crypto library. He also worked on integrating these capabilities into Thali and updating the Postcard app to be able to use them. He also helped with some early work on implement a prototype of our notification system’s crypto using the extended APIs.

Sreejumon Purayil - Sreejumon worked on Thali from 4/2015 through 8/2015. He helped to create the initial version of the Postcard app that demonstrates what Thali can do and worked on the install and logging infrastructure. Install in particular was a nightmare because we had to get Android, iOS, Cordova and Node all playing well together.

Brian Lambert - Brian worked on Thali from 3/2015 through 7/2015. Brian created the foundation of our iOS code including figuring out how the heck to make BLE centrals work in the background, how to get an iPhone to be both a central and a peripheral at the same time and how to integrate the multipeer connectivity framework. He also was the original designer of the native API we use to communicate from JXCore/Node.js to native code and debugged through a lot of tricky issues in the early days of JXCore’s native plugin api on iOS. He still helps out from time to time but now has moved on to lead his own project.

For just over a month in 3/2015 we had the awesome help of Wenhui Lu who had a really hard job to do that we can’t really talk about yet, but he did it well and without complaint. We are grateful!

Jon Udell - Jon started working on Thali in 2/2014 and continued to work on it through 12/2014. He was thali’s first PM, first advocate and first user!

The summer of code

We had what I jokingly called a “summer of code” like event back in 2014 and the following folks spent a few weeks helping Thali out. They worked on our now deprecated Java codebase which is why you don’t really see their contributions. But it is because of their contributions that we were able to convince our senior management that this Thali thing could work which then led to them wanting Thali on more than just Java which led to our work on Node.js. So in a sense they wrote their own code out of a job.

Stefan Gordon - He single handedly got our Crosswalk based HTML front end working on Android and then put together the NanoHTTPD infrastructure that let us host our content on the desktop in the browser.

Ivan Judson - He wrote our first Javascript/PouchDB based address book, was the first guinea pig for Stefan’s work and managed to survive the awful hell of trying to scan QR Codes in Javascript.

James Spring - He hacked into both the Javascript and the Java replication code so that we could manage replication between devices in a way that didn’t instantly crash. This was a huge deal for our demo.

Jason Poon - Jason got Jenkins running in Azure so we could start doing cross platform testing and also worked a bit on getting Jenkins running locally.

Tim Park - He wrote the demo that convinced our upper management that someone other than me could actually use Thali! His deliver was a big part of getting us funded!