Understanding the technology wave and its effects on project

I've used multiple early wave technologies from UnityPark suite to Unity on its first windows version to more radical stuff I'm afraid to name here. Recently I've worked on a project using unity's new networking library uNet and made it work in a way that a server can host a game for both webGL and mobile clients at the same time. This specific act and making a real-time multiplayer game with 16 players work in webGL and uNet wasn't something that many people have done before and it wasn't without issues but I've fixed all of them with hard work and help of my employer and engineers of Unity. I've used many early wave technologies before too but this time felt it's good to share my experience in this regard with the gamasutra community.

Why it matters to think about this?

Software is complex and there is no skipping from that. Software systems try to either mimic or improve the real life processes and the universe is complex with all of its simplicity and beauty so we cannot make software or software development easy. Even if we could just tell a computer what software to make in plain English or in all languages which exist in the universe (yes Klingon included) it would remain highly complex since it's not easy to think about all possible cases and exact processes and also because universe is changing and it's changing fast.

Truth is that the current way of writing programs makes it even more complex and error prone. Still languages like Rust are being introduced to make it more secure and robust but still it's hard. It's very hard in fact up to the point that software development in a good manner is a skill which not many possess in our industry.

The above means that when a software system is built, even if it's built by a good engineering team from a big company, it requires time to get as good as it should be. There are so called waves in each technology's life cycle which you should understand. Let's say there are 3 waves or stages, at first it's an early wave with lots of issues and corner cases not considered, they might even have unstable API surface. Then things get more stable and ready and still bugs exist and you might try to do things with the tech that no one else tried to do before so Google's casino (or Bing for us Microsoft fans) cannot help. and there is a third wave which mature software exists in which for most if not all issues or cases there have been many users before you and you can solve issues quickly and rely on the software system to ship a great product.

Why use a technology in its earlier waves of development?

There can be multiple reasons. Simply there might not be a better alternative to use overall like usage of WebGL for rendering content in browsers which don't allow third party plugins.

There might not be a better alternative in your platform. Let's say you want to use a high perf networking library in the .NET world and dotnetty is in its early stages but you cannot move to Java world to use netty and change your whole infrastructure and code base because of that.

The technology might have a bright future backed by a big community and/or a big company with serious investment in it. For example probably people use early previews of technologies from Google or Microsoft because of this. These kinds of project usually grow fast and get mature soon enough.

The technology might provide new hot features which can provide great advantages to your product/service. This is kinda similar to not having alternatives but in this case you might have alternatives but the stable mature alternative doesn't provide the exact set of features and has a different viewpoint. For example if you want to use a physics engine , PhysX is very mature but if you want deterministic physics you have to use Newton dynamics despite the fact that it's not as mature or stable (maybe).

How to find out which phase a technology is in?

This is usually not too hard. If some stable products have been built on top of the tech and Google searches usually lead you to correct answers or at least good clues on what to do, If the tech is out for some time (1-2 years) and people are still using it and like it, if it has a sizable community around it, If releases and fixes are coming with a good speed, Then you can consider it mature tech.

Sometimes it happens that products lose quality in their lifecycle like what happened to stability of some well-known products in the last year but good companies will either get stable again or will simply die and finding symptoms of degraded quality is not too hard if you look it on the web. Generally it doesn't happen too much in the more professional sector and can mostly happen to smaller projects which lose funding or key personnel.

Are mature technologies bug free?

If space shuttle software has issues (they verify their software using formal methods) and if Microsoft still fixes bug in their damn good, damn stable C++ compiler which Windows and Office run on, trust me every software on this planet which is doing a complex enough task, HAS bugs. The difference is, in stable software bugs are fixed faster than none stable ones and they are usually minor and can be avoided by one way or another so you workaround them somehow. At worst you'll lose a feature or two but your life will not stop because of that.

How is the best way to deal with early wave tech?

Most of the times people try to use very early tech as a hobby or because of anticipated gains in the future. After that very early phase (think alpha / technical preview software) technologies are more usable but have shortcomings. If you want to/have to use them for your production then the best thing is to estimate some good amount of time depending on the history of the technology in its earlier phases and the company developing it, for fixing bugs and resolving issues. You should try to work as closely as possible with the original developers to find and reproduce and fix problems and add needed features to the software system. If it's open source and available on GitHub or something, even trying to help directly by contribution if you can afford it technically and otherwise is even better. It's great because you gain a better understanding of the system so can solve your own problems faster and also are investing in something which you will use a lot in the coming days and months. And here I'm only talking about direct selfish benefits of it to you and your product and company, Of course indirect benefits are a lot and motivation for them is a great thing.

When to avoid early wave technology?

If you are building something which its delivery time and correctness are critical in one way or another and you have any options, use the options since unknowns of early wave technology can ruin everything for you. In these situations use these kinds of tech if you really have faith in the development team and/or have the engineering power to help fixing all show stopper and critical issues while working on your own product using the technology.

A good example is the 343 industries team using Microsoft Orleans hot from Microsoft Research when it wasn’t used in production before. They knew this will have a great amount of gains for them and their users and also they knew they could count on the Orleans team and will be able to solve any issues. Also they could rely on the high standard of engineers and scientists at MSR and the quality which a product is built in there.