What is a Make Day?
Make Day Juliett was one of many "Make" days that OfferZen is offering to local developers around South Africa.
OfferZen is hosting 20 developers per Make day to join in a full day of building things (hence the name) in a low-pressure environment that is focused on learning. You can find more details about OfferZen's Make platform here.
What is Make Day Juliett?
Make Day Juliett was hosted by OfferZen and Root. Each Make day has a theme
and the theme behind this Make day was that you build a chatbot utilizing the Root API. The essential takeaway of the day was to learn about building insurance chatbots. The elements
that were focused on were namely:
- Root's brand new Insurance API
- Chat interface of your choice: Facebook, Slack, Google Assistant
- NLP (Natural Language Processing) tool DialogFlow (previously API.AI)
If you want to find out more about the day then just look at this PDF which explains all about the Make Day and Root's insurance platform.
After being invited, OfferZen Make gave us some prep work to look at. The prep work mainly consisted
of finding out about DialogFlow and Root, setting up our Root API accounts and making a request to the Root API.
The prep work was vital for me as it ensured that I had a clear understanding of the technology that we would be using. The prep work was
optional however I decided to revise it in order to ensure that I could get the most out of the day. My aim was to build a chatbot and learn
about DialogFlow and Root insurance, not struggle getting my first intent setup or anything mundane.
Start of the day - 8:00am
The day started with all 20 developers going to the OfferZen Make space in Kloof street. Initially, I was a bit nervous about
who I would be working with and what I would gain from this day. I knew one thing and that was that I was very excited to learn and the theme behind
the make day was very appealing to me as I am quite interested in ChatBots (as you can tell from my other blog posts).
This worry was quickly dispelled as I was met with a friendly space filled with coffee, fruit and snacks to start the day. I first met every developer and we all introduced ourselves and then created a name badge that featured
not only our names but also what language we wanted to work in on the day. This was great as we knew that we were going to team up and being able to see who might be a good fit to team up with based on language
or interest was a great idea. In terms of who was there, there were developers of all skill levels which was refreshing. There was namely CTO's, juniors, fresh graduates, developers, senior developers so the group was very diverse and this allowed for new perspectives and ideas.
The event begins - 8:30am
After the meet and greet and breakfast, the event officially started, we all gathered in the Make Space and OfferZen presented various talks on what we would be building. We had a talk on what Make Days are about and what the platform wanted us to gain as software developers.
A vital point that was presented was that this isn't a competitive hackathon, the idea isn't to build the greatest chatbot and win the event. The idea was very much a learning experience
and even if we didn't finish, the point was to learn and do something new. This was a great idea as quite often in workspaces or at other coding events, the focus is very much on
deadlines and finishing the product which offers little flexibility for learning something new when you are expected to be knowledgeable and perform well.
Root then presented a short presentation on what Root is about namely a bank card for software developers. The presentation also covered how the Root Insurance API works
along with an example of creating an application and issuing a policy to a user in this case for insurance. This was a great addition as it gave us insight into how
the Root API works.
The next presentation then focused on how DialogFlow (previously API.AI) works and how to implement it. This was essential as quite frankly the learning curve
around DialogFlow was not shallow so this presentation helped a lot in terms of the basics and getting to know about intents, entities and actions.
What I really enjoyed about these presentations is that the entire presentation slot was short and each presentation was around 15 minutes, this helped as it allowed
for more time to do as the event suggested, "Make" things!
Teaming up - 9:30am
After the presentations, we all stepped out for coffee into the break area and developers started teaming up, this was really cool as people often teamed up
with different people of different languages. A 3-person team even teamed up and decided to do the project in a new language altogether, I decided not to opt for this approach as I was more interested in learning about DialogFlow. I teamed up with another developer who also opted to use PHP for the project. The teaming up process was easy and within 30 minutes, we were all at our stations and ready to go!
Working on Bots - 10:00am
We decided to build a Slack bot using the wonderful PHP chatbot framework BotMan and DialogFlow and then hooking into the
Root API. After some initial planning, we began working on the project. The idea was to allow a user to issue a command namely "Insure my iPhone 5" and then the bot
would create the relevant insurance quote and then after some basic questions would allow the user to create an application and insure their phone! I utilized DialogFlow
to handle all intents so while the logic was in BotMan and that handled the API work, BotMan itself was just listening for an intent and DialogFlow had the
actual job of recognizing user input and then sending an event to our BotMan app.
The way that we developed the project was in-tandem, we used a single monitor (that OfferZen provided) and essentially pair-programmed
our idea to completion. This was a really interesting mechanic as it ensured that team worked together and offered input. Pair programming was a great format for the Make day as it is a tried and tested
way of learning new things. My team-mate and I continuously bounced ideas back and forth and reflected on how best to solve a problem or architect the application.
This structure ended up working out very well and while it was a bit frustrating to
get DialogFlow to work as intended at times, the app ended up as follows:
What really helped a lot was that software developers that have previously attended Make were there as Make "masters" and were around to offer guidance if needed. This was beneficial as
they not only offered guidance but also some suggestions for the projects.
The entire day they were moving about and helping software developers with their projects. What was also vital is that Root developers
were available to help with any queries regarding the Root API. This was very beneficial and I think some form of direct communication is important regardless of what platform we are working with be it Root or another service especially
when building software with that service in a time-span of one day.
At the end of the day, every project was at various stages of completion and this was perfectly OK. Some had completed their projects and others had made
great progress or ended up focusing on one portion and learnt a lot there.
Retrospective - 5:30pm
At the end of the day, there was a short retrospective hosted by OfferZen around a whiteboard. The name of the game here was that we all offered feedback
on 3 key topics namely:
- What tech stack did we go with and what was our idea?
- What did we learn from the Make Day and would we come back?
- What was missing from the Make Day & what could be improved upon?
After this, everyone simply answered the above questions and it was found that my feelings of apprehensiveness were not alone as many of the other software developers
were worried if they would be cut out for it, this may have however just been a case of mass imposter syndrome =)
A very nice element was that nobody presented their application and the benefit was two-fold. Firstly, it didn't matter how far you had come, just mainly that you learnt something
and secondly, it removed the element of competition from the Make day as there was going to be no judging of your application at the end of the day.
What did I learn from the Make Day?
I learnt a lot about how DialogFlow works and also how to setup BotMan with DialogFlow. This was a great takeaway as I'll definitely
leverage DialogFlow in my future chatbot applications. I also learnt a lot about the Root API which was a really cool experience as the Root API was very easy to work with and the documentation was incredible! I went from 0 experience in the API to allowing a Slack user to insure their cellphone!
Would I go again?
In conclusion, I found the Make day to be a refreshing way to learn new things especially with other people rather than sitting down at a desk and reading a book.
I personally learn the most when I am working on a project and so this approach was perfect for my taste. I also found the aspect of continuous pair-programming to be
a very beneficial element of the day as it allowed for continuous feedback and new ideas when creating the application, after all, two pairs of eyes are better than one.
I'd definitely be back for another!