Learning Process: 2. Scope

Last Update: 05.02.2019. By Jens in Newsletter

The second step for a successful learning path is the scope of what you will digest. For us devs, it’s the apps we build while learning the new language or framework. If it is too big, you’ll fail. I did fail many times. Once I head out to build an MMORPG with 3 co-workers. That was an ambitious goal. 4 guys wanting to build a game of the scale of World of Warcraft. Maybe we even removed the first m (massive) and just build a multiplayer RPG, I don’t remember that.

What I do remember is that we all started out as experienced devs, yeah, but none of us had ever coded a game, nor worked with 3D graphics and alike. We had some ideas what we needed like maps, terrain handling, movement of player and npc and what else. Even simple dialogs were hard at that time in the 3D world.

Anyways, I think we worked for around half a year on that until it died. The first guy almost directly quit from the beginning. He actually never coded anything, so it was three of us. For that, we got pretty far. You could walk with animation on a terrain, almost endless and parts generated, with smooth terrain transitions, place objects and it even had a nice water animation effect. In the end, a lot of the motivation died because it was so slow and we finally hit the problem of having 3D models. Yep, we even tried to do them ourselves with no clue.

Essentially, the scope was way too big and the approach did not work.

What works better on the other side, is to reduce the scope a lot to almost ridiculously small as I did with my recent Mac app. It still sums up because like with estimation, we forget or ignore to count in a lot of details. I recommend also to build something where you have the domain knowledge. For example, a simple Kanban or Todo app. Simple logic, simple rules. A bad example is building a financial calculator when you to learn the business logic alongside. Focus on one thing to learn, not multiple.

In my case, this was a small reminder app with playing a sound. Let’s look what was actually involved:

1. getting comfortable with a new IDE; build, debug, auto-completion, and finally packaging the app
2. Basics of the Swift syntax
3. How the main app starts (think of the Java main method)
4. displaying a window
5. Displaying UI elements like buttons and labels
6. Layouting of the UI
7. Triggering a method on a button click
8. Playing a sound file
9. Timers
10. connecting a Label with a variable
11. opening another window in the app
12. Displaying the app in the menu bar
13. Make it windowless
14. Adding an AppIcon
15. Adding the menu bar icon
16. and few more You see? It looked straight simple from the outside but it is not if you have never done anything of those details in a new language or framework. It gets harder if you have never done them in any other language so far. For example, if the only UI you know is a command line, then the concepts are new for you too. Count that in.

When I got that many steps, I usually break the scope down into smaller scopes and tackle them in a row. For my example it looked like: 2. Run an empty app 4. Turn it into a menu bar app 6. Add a menu button which plays a sound 8. Add one timer 10. Add a series of timers (start a new, when one finishes for the next interval) 12. Add timers logic plus preferences 14. Make preferences configurable 16. Deploy app So, instead of one to big scope, I sliced it up into multiple smaller ones. And for each of them, I go through the learning process.
-