Early Wave Programming

During my summer intern-ship I got to start an Angular2 project using typescript. I was super excited to work on the project and started hammering at the available documentation.

Angular2 was RC4 at the time. I was pretty confident that RC meant no major changes will be made to the framework until the release, some fixes maybe but nothing major, and boy how wrong I was.

I followed the first tutorial and I got a glimpse of what the framework will offer. I decided then to create a dummy website to test drive the framework. In no time, the website was up and running.

Feeling pretty confident, I started working at the project at hand and things started to look gloomier. During the development, I followed behaviour-driven development process. Thus, making sure tests were written for every feature.

Getting third party content to work was a nightmare. No documentation was available. It was all trial and error. And error messages were hard to understand. They sometimes lead you into a wrong track.

After a month of work, I was able to implement most of the features. Then RC5 was released. I was excited for the new update hoping for some bug fixes to be released. I looked at the change log and the inevitable happened (Change).

I was shocked to see that most of the features I was using became deprecated and will be removed by RC6. I can't say I was prepared for this but I managed to migrate the project in one day. What helped me was following best practices and making sure that modules are decoupled. So the change was limited to a small number of files ( in my case 3).

This experience made me realise the importance of knowing my location on the programming wave.

Early wave vs Late wave

Early wave refers to new environment while late wave refers to mature environment (naturally).

While using a mature environment there is a wide support offered. Integration with IDEs, well documented frameworks and rich communities to site some examples.

On the other hand, new programming environment do not have the privilege of having a good support. Libraries are hard to find and when you find one you are not sure if it will work well with other component of your software. Documentation are either unavailable, incomplete or sometimes they are outdated.

While using an early wave environment you will be faced with more challenges. Most of the time you will be looking at how things work instead of implementing new features.

Things to keep in mind

So to tackle these challenges you need to keep these things in mind.

• Have tests in place from the start because things can (I must say will) change frequently.

• Keep your components decoupled.

• Make sure you follow the Single responsibility principle. So changes will be limited to a small portion of your code base.

• Do not get frustrated if you feel that you are the first to encounter a problem (Sometimes you are the first).

• Do not be afraid to report the problems you encounter to the community. They can help you.

Conclusion

Using new technologies allows the use of new features but can cause more pain if we are not vigilant.