Month 1: Course 1

Step 1 — Leap of Faith

It was a normal day in the office at work, I recall I was trying to explained to some co-workers how Blockchain could be used in more ways then just as a currency. It annoyed me that I couldn’t summarise my knowledge of the topic concisely enough to make my argument valid.

I remember blurting out that I would just put together a learning session for the team on how Blockchain technology could be used in a practical way. I don’t think people took much notice, but in my mind I was screaming…

What have I done!

I’d committed out loud that I was GOING to make a short course.

I remember sitting at home that night stressing about what I was going to teach, how I was going to structure it and what needed to be taught; and that’s when I decided to check out some online courses to see how they were teaching things.

That’s when I found Udemy.

Immediately I saw more value in producing a short online course and then giving it away for free to my co-workers, as it gave me an interesting challenge. It meant that I didn’t have to stand up and present something in front of actual people and I could just talk to a camera.

Step 2 — Find your Niche

At this point in time, the category for Smart Contracts / Ethereum / Blockchain Development were pretty lacking in terms of available courses. There was one other big course on Smart Contract development that seemed to have everything under the sun:

• Awesome Course introduction video (really neat animation and effects)
• Introduction to the Toolchains needed to get started
• Introduction to the Technology in general
• Introduction to the Language used to write the smart contracts
• A very simple demo application

Cool… Awesome… Now what?

That’s when it hit me, sure there was a course on how to get started with some really basic examples; however while these learnings are really important for some, it doesn’t really help new developers to this landscape make anything that is worthy of use in the real world.

A quote came to mind

Learn Programming Patterns, Not Programming Languages

This basically means that learning a Language is always interesting and useful to a point, but at some point you have to apply that language to a problem that is completely unique to that language; and you will fall flat on your face.

Really what I immediately decided I wanted to do, was to teach the technology in a VERY hands on and raw way.

What I didn’t realise at the time as that this is a very risky game to play, especially in a land where not everyone is looking for this kind of course.

Step 3 — Fail Fast, Fix Later

I spent a good week or so designing how I wanted the course to me structured; I spent entire days just thinking about what things I wanted to teach, and in what order I wanted to explain them.

I felt like I was being productive

I felt good about what I was getting through, It seemed like I was making a lot of progress, I mean I had all these great Ideas down on paper and I had this amazing fantasy in my mind about how it was all going to come out when I started filming.

I wasn’t ready to start filming though, Noooooo Nooooo way was I ready, maybe next week I will film the Introduction… ohh but wait I should film the introduction last because I don’t know if I’ll change things, Oh maybe I’ll film it at the start and then If I change it I’ll re-film it, but then…

STOP

By the end of the second week I realise I had fallen into a pitfall of building my own barriers around why I couldn’t just get on with producing videos.

It was worse because I knew that I was going it to. I would go to bed telling myself I’d done so much, but then toss and turn from feeling guilty that I’d wasted 4 hours making a new Course Image.

I decided one afternoon that I just needed to cut the crap and get started; even if the videos weren’t perfect, at least maybe I wouldn’t feel so guilty.

I started filming.

5 hours later and I’d finished a draft cut of my ENTIRE course.

I slept soundly that night

The overall quality of the videos were no where near the Wes Anderson masterpiece I’d initially envisioned. But at-least it was more or less out of the way.

I submitted my course for review, and it was approved pretty quickly; however there was a note from Udemy with feedback that the audio was a little Quiet and that you could sometimes hear noises in the background.

Note: I recently went back and re-mixed ALL the audio for my videos removing background noise and added annotations to complicated sections. I did this after I launched the course when I had a couple people mention that it was a little hard to hear in places.

Step 4 — What Now?

I launched the course and I felt great! Over the moon! The next day at work I handed out a bunch of free coupons to my co-workers and told them they should check it out if they wanted to learn more.

I kept checking that Instructor page, hitting F5; but nothing really changed. I didn’t get any new students, even from the free coupons. Not only that but most of the people who I did get to sign up didn’t sit through the any of the content at all. I didn’t really expect anyone to, but I sorta hoped that I was going to see at least some student flow through from Udemy’s store front.

Nothing

I read a bunch of comments from threads that I could relate to on the private Instructor page on facebook that Udemy runs, and realised that self promotion is pretty much necessary to get courses off the ground.

I was part of about 20+ discord groups that all revolved around Ethereum games, I can’t remember why I joined half of them but it seemed like a really good place to start looking for potential students.

Before I went around posting links however; I wanted to develop some more detailed graphics to catch the attention of people. Because the Udemy course guidelines didn’t allow for text, I had to develop something else.

The first advert turned out to be not super successful overall, it did lead to some sales; however I have a feeling that most people only bought the course because of the text block I had accompanying the image.

Over the next 3 weeks I changed up my visual strategies and eventually began advertising on Reddit, which has been probably the most successful out of the major advertising platforms out there.

Smart Contract Development: CryptoDoggies Token Game

Month 2: Course: 2

The development of my second course The Complete Flutter and Firebase Developer Course went a lot better in terms of productivity. I don’t want to repeat myself, so I’ll summarise the key things I picked up during the production.

Co-instructor

I worked with a Co-instructor this time around which was really helpful for developing more content, and also having someone to proof read the things I was delivering was great.

Advertising

I went WAY too hard on advertising early on, I was only just breaking even because there are only two major courses that teach Flutter on Udemy at the moment. I was making most of the revenue from Affiliates and Udemy advertising.

After about a week I cut back to just Reddit ads.

Promotions

I wish I’d started promoting much earlier on in the courses life, after about a week and a half a I started giving out Free coupons to a couple facebook groups I was part of specifically focused on the subject matter I was teaching.

The feedback and responses I got from this were fantastic! A lot of positive vibes overall and heaps of constructive feedback.

Source Code

This time around I didn’t skimp on source code as course material. I provided code chunks for each individual video.

The students could download that lessons source code and pick up from anywhere in the course without having to go back through videos to find what they missed.

Unfortunately I have noticed that a good number of students don’t seem to use this resource nearly enough, and I still get a fair number of “This code isn’t working for me” Q/A’s where its a simple syntax issue where code hasn’t been copied in correctly.

Misc Resources

I spent HOURS making up supplementary materials for literally every video in the course. It allows people to follow up from the slide presentations and they help me when I’m teaching content to remember which parts come next

Scripts don’t work for me at all, and I’ve found the slide methods make the videos seem a lot more natural for me which the added benefit of being an excellent resource for my students.

YouTube Promotions

As part of our ongoing content, we produced part of our course for YouTube as well which allowed us to potentially draw in some interest for Flutter by targeting the main language it uses.

It’s still too early to say that its working, but at the very least it’s providing a service to the overall community!

Now What: Part 2

We’re still delivering content to the course in a steady manner, We’ve taken on a lot of feedback and the originally 4 section course is already nearly 7 seconds now; going from the original 4.5 hours to nearly 7.

We’d like to continue to improve as we go rather then making another one for other pieces of information, we’ll see how long we can add videos while still keeping the content logically ordered.

The Complete Flutter and Firebase Developer Course

Summary

Overall the experience has been fantastic, I’m definitely sleeping less because of the amount of time I have to put in after hours to produce good content, but it makes me happy to do it.

I’m currently working on my next course, which I’ve just finished writing all my slides and material.

About a month ago I heard from a friend about a great new mobile development framework that promised to simplify and streamline the process of pumping out iOS and Android native applications using a unified code base.

Flutter is Google’s newly beta released Native mobile development framework. Its biggest appeal to be was quite honestly the fact that its primarily written in Dart. It makes use of this connection with dart by also utilising a wonderful external packing tool pub.

CatBox Adoptions

CatBox is an application that I wrote with my good friend Rico Beti, and is based on the FlutterMates template which I found in the awesome-flutter repo.

Our goals were to make use of as much of the “Standard” Flutter stack as we could, this meant we wanted to integrate nicely with Firebase and try to build our app to be serverless.

The final project implements:

1. Firebase Authentication, specifically Google Sign-in
2. Cloud Firestore, NoSQL database for our cats
3. Firebase Storage, hot file storage for the cat images
4. Firebase Functions, handles a couple of our Firestore queries for us safely.

Check out our codebase, It contains everything you need to deploy it yourself, including all the Firebase configuration files that use firebase-cli to deploy!

Flutter and Firebase Developer Course

On top of the base repository, we also developed our very own Udemy course where we go over the entire projects implementation + cover the general setup and beginners guide to Flutter Development.

We wanted to make a course that didn’t just create mini apps, but more so we wanted to be able to teach what we’ve learnt so far, and continue to build on the course as we continue to grow the CatBox application, which is currently Live on the Play Store

Use the coupon code MEDIUM2018 to get the course at a 88% discount.

It’s been over a month since I updated the KittyCoin Club repo and I think I owe some kind of explanation for people who might not follow what I get up to on other social platforms *cough*.

Near the end of January I realised I’d fallen into a development pit where I would be pushing small, and arguably pointless changes to the repository. Unfortunately my basic knowledge about JavaScript, Bootstrap and web development in general was proving to be a hurdle that I didn’t have the enthusiasm to overcome.

So I pivoted to something new for a while!

CryptoDoggies Udemy Course

I created an online course that was designed as a way to force me to learn the practices I’d picked up over the previous month and apply them to a fresh and simple ÐApp (Distributed Application).

One of the side effects of doing this course, was I ported my existing copy-cat implementation of the Kitty image generator over to a Doggy; and I actually learnt how the base code works and created a new version t04glovern/doggy-id-parser

The site itself is extremely similar in a lot of ways to KittyCoin Club, however I optimised the way I was dealing with Bootstrap cards and cleaned up a lot of the JavaScript that I was using; making it more readable and less verbose duplication.

The idea behind the application is fairly simple, and just implements ERC721 token standards in order to create and store these unique little collectable doggies; whose price increase each time someone buys it off you.

ÐAppster

ÐAppster is a fork of an existing card based advertising platform called WeiCards. What ÐAppster tries to achieve is to create a place where people can purchase a digital billboard; that once own they have complete control over what is advertised on it.

When a card is purchased the owner can do one of three things

1. Sell: the card can be put up for sale to anyone looking to buy for a price specified by the owner
2. Lease: The card can be rented out for a set period of time at a fixed rate
3. Advertise: The card can be used to advertise both an Image and a URL link to a website.

KittyCoin Club?

Good news! I haven’t forgotten about the smart contract idea that started it all, and It’s now back to be the main focus of my attention. I really did just need a creative break to explore what else was out there; and deploy some other interesting ideas to mainnet.

Over the next week I’ll be taking a large portion of my CryptoDoggies learning and porting it back into KittyCoin Club, along with changing up how I deal with the KittyCoin tokens.

Links

• Smart Contract Development: CryptoDoggies Token Game: https://www.udemy.com/cryptodoggies
• CryptoDoggies code: https://github.com/t04glovern/cryptodoggies
• CryptoDoggies ID Parser: https://github.com/t04glovern/doggy-id-parser
• ÐAppster: https://dappster.space
• ÐAppster code: https://github.com/t04glovern/dappster

Another week down and a lot of progress has been made. This week brought a major overhaul around how I do unit testing, which had some fantastic benefits around cleaning up some critical bugs. There was also some progress made on the front end connection to the backend data for each of the primary data structures.

Unit Tests & Coverage

In order to correctly unit test some of the more complex chain of events that take place in my DApp, I needed to restructure the way my unit tests were called, and move away from instantiating a new instance of the contract before each test (I was using beforeEach() ).

The new method, which I borrowed from MoonCatRescue, stores a generic interface for each test case and accepts account[x] style arguments so allow for more repetitive function calls to be carried out without sacrificing too much readability

The code block above for example, will allow me to test a variety of different scenarios and confirm whether the scenario should succeed, or fail by simply passing a expect to fail argument when necessary.

// account[1] should not be able to give trust status to account[2]

checkCanApplyTrustToAccount(2, 1, 'expect to fail');

// account[1] should not be able to give trust status to themselves

checkCanApplyTrustToAccount(1, 1, 'expect to fail');

// account[0] should be able to give trust[0] to account[1]

checkCanApplyTrustToAccount(1, 0);

// account[0] should be able to give trust[1] to themselves

checkCanApplyTrustToAccount(0, 0);

This new scheme of testing resulted in an awesome bump in code coverage, and has really enabled me to work a lot faster without worrying about creating too much technical debt.

Font End Communication

The second change is around how it communicate to the frontend application using the web3 library. Prior to this week I was pulling from a function that just listed the identifiers for the various data structures; this week I managed to get the actual data from the testnet displayed in the console.

This is a pretty major step forward, as it shows that all my contract logic is working perfectly, and is ready to be displayed in more useful ways this coming week.

I’m at the point where I can nicely test all the functionality from the frontend directly; be it creating trust, adding kitties or making donations! All that’s missing now is the UI elements updating based on blockchain changes.

MetaMask Redirects

I have a redirect page for people who don’t have MetaMask enabled when they first arrive at the site

I still have to clean up some of the logic so that after connecting to the correct network the page auto redirects back to home without requiring a manual refresh.

Trust/Foster Overflow Bug

Had an awesome win around removing a logical bug in the Trust/Foster amount overflow calculation.

I won’t get into the details, but I didn’t think about how I was calculating the trust amount and had some odd cases where the Unit tests would work, which made me believe I didn’t have broken logic.

Plans for this week

• Implement ERC721 tokens underneath KittyCoin’s
• Get code coverage over 75%
• Replace the temporary kitty cards with the Sprites generated from the kittycoin-id-parser library.

This week felt rather unproductive in terms of visible deliverables for the platform, so I figure I should start updating the progress made on KittyCoin Club each week to keep me motivated to kick goals.

Unit Tests

The main focus this week was Unit testing and to iron out as much of the technical debt as I could now, so that I don’t end up with monster problems in the future. I could also argue that the Unit tests will help me move faster developing now, as It’ll allow me to test new ideas more quickly.

I’m currently testing the major functionality of the contract in three main tests; this code can be viewed here. I had to learn quite about about how JavaScript async, await and promises work; which gave me such a massive headache while I developed.

Interface Additions

The next piece of rather large work that I crushed was a more interactive interface on http://kittycoin.club.

You can now, granted you are registered as a trust; create kitties to be put up for donation. This is coupled with another small form that allows the contract owner, and eventually other trusted users to add new trust addresses.

The next step for the interface is to replace the existing Kitty images with new Kitties that are added to the contract. I actually finished a lot of these backend functions as well, however they are not fully linked to the frontend quite yet.

Better Issue Visibility

The final thing I would like to mention is that the project now has much better issue visibility. I’ve integrated https://snyk.io and https://codeclimate.com which perform both security/vulnerability scans on the static code, and also analyse the code maintainability (takes into account duplication, code coverage and code smells).

All this information is available as badges on the repo’s README, so problems are brought into the light rather then ignored.

Final Notes

1. We’re now featured on State of The Dapps 😻
2. This weekend was the first time I had my contract saving and loading data, and making payable transactions to the development blockchain (which is really really exciting, as it took a lot to get everything coded safely).
3. SafeMaths & other zeppelin-solidity offical libraries are now referenced in the code, meaning I’ll be more likely to integrate future changes from those projects.
4. I’ve learnt SO much about JavaScripts testing frameworks, and also web3 transactions and contract communication. It’s really cool!

When I decided a few weeks ago that I wanted to build a DApp (Distributed App) I made a conscious decision to bite off more then I could chew. The reasoning for this was that I didn’t want to create yet another gambling app like a lot of DApp’s are doing currently.

Along with this I’d also begun working on a small home project to help my partner and I track and publish the cats we were currently fostering for our local animal rescue.

I decided I would merge these two semi-different things into one (hopefully) helpful platform that would use the Ethereum smart contract system to organise and incentivise donations to both Foster Carers and Animal rescue organisations.

KittyCoin Club’s site is currently “Live” at http://kittycoin.club/. However the contract is still actively under development and I’m hoping to finish up deployment in the next week or so.

The components of how KittyCoin Club functions can be vaguely outlined in the diagram below.

Trusts

Trusts are the organisations that are already registered as charities under their local governing system. The trusts initially need to be added through the contract Owner (myself), which understandably goes against the decentralised nature of the DApp. I’ll try to justify though, and say that simply opening up the platform to anyone to add animals to generate donations simply will not work without some form of governance. I’m closely watching the work that https://giveth.io/ is doing, as I believe a public governing body will eventually be the format this DApp will abide to.

Kitty

Kitties in actual fact are entities that can be donated to, and can only be setup by verified trusts. A Kitty will take a variety of unique traits that define what it looks like, the idea being that I can eventually implement a sprite/palette swapper to visualize the kitties on the DApp’s page. Currently I’m using a centralised asset store for each image that links to a kitties ID. I’ve looked into the cost of storing images, or even image hashes on the contract but the pricing is ludicrous! I’ve also played around with some simple sprite palette generation on some kitty images.

The repo kittycoin-id-parser allows me to turn a series of small 8-bit images into a huge assortment of unique kitties defined entirely by a unique ID.

I’d really like to apply this simple concept to the fully fledged kitty designer and allow trusts to store accurate depictions of kitties they put up for donation in the smart contract via the trait ID.

Donation

Donations are applied to Kitties and take two arguments from a donator. The first is a total Ethereum amount they want to donate, this amount is out of a total defined by the trust as a target donation limit.

The next argument is the percentage of the donation that should go to a foster carer vs the trust. I should explain that the main reason for this entire platform is to alleviate the financial strain that foster carers usually bare when looking after kittens and cat in-between homes. Usually they don’t get much in terms of financial support from the animal rescues, which isn’t the fault of anyone other then the fact that it is logistically very difficult to manage financing foster carers (and in most cases they’re doing it out of the kindness of their hearts).

So in reality the donation limit is primarily there to stop a foster carer from getting too high a sum from donations. When a limit is reached, and additional donations go straight to the trust in charge of the kitties donations.

KittyCoin

KittyCoin’s are the tokens of this platform. They are meant to incentives the donations that are put through the system, as they are unique and structured to be collectable. The coins themselves have a highly unique seed that is used to define a plethora of traits the coin exhibits. I don’t want the Tokens to be the primary reason people use this platform, however I also understand that some kind of reward would be welcomed, and the KittyCoin’s are both a nice token of proof that you’ve done something nice, and also the collectable and rare nature of some coins will encourage more people to donate to collect.

I won’t give away too many secrets just yet, but I will say that you should watch this space closely 😻

Summary & Links

To wrap things up, I’ll leave you with some links to the project so far.

Main DApp Repo: https://github.com/fluffycatware/kittycoin-club

Main DApp Site: http://kittycoin.club/

FluffyCat Tech Site: http://fluffycat.tech/ (this is the overarching org site for all future endeavours around blockchain for the greater good)