In the previous stage of production, we sat down and came up with all of the different stories that our tool will need to satisfy the goals of our tool. We could have spent a lot of time in planning, but after some consideration, I realized that the plugin should not be that complicated since we are mainly dealing with an I/O (Input and Output) process. What I mean by I/O is that our tool will need to read some information from an external source (our MaterialX file) and import that information into Blender. Once the information is in Blender, then the host application takes over and our tool should not need to do anything more, until its time to do an export.
Of course, this is not the only way to write this tool, but I believe it is the fastest way to get something useful in front of end users so that we can start getting feedback. This is part of the SCRUM methodology, get to working software as soon as possible, so that the "clients" can start using it and reporting back any required changes.
UI Prototyping
This is a step which can be completely skipped if what we are building is a batch (or headless) tool. As a TD, you will find that there are many tools which can and must be written without accessing a user interface, especially if this tool is part of an automated workflow.
If the tool we are building is an interactive tool, then the next step will be to put together a quick prototype of what the UI will look like. When prototyping the UI we need to take into consideration all of the stories that were written down during the previous stage. Well, not really all of the stories, but we do need to include GUI to address the most important stories.
To do the GUI prototyping you can use any tool you please, as long as it allows you to express your idea clearly. I have sometimes used photoshop for this tasks. Sometimes I also use affordable wireframing tools such as moqups or balsamic. Whatever tool you are comfortable with, should work.
Avoid going into small details such as colors, size of fonts and button separation at this stage. Those are details that can be addressed later on. What we are really after here is to make sure that our GUI allows the artist to perform all of the tasks that they need to do, in a way that is easy to understand and as logical as we can make it.
Once I have a GUI prototype that I think will work, I tend to share it with the artists that will be using the tool to get feedback. The feedback that you get from the users can be extremely useful, especially when it comes to improving the usability of your tool.
Remember that a tool is only as good as it is used, You could build the most amazing tool that does the craziest things, but if the GUI is something that the end users cannot understand, then such tool will not get used.
Since we are building a simple I/O plugin, then I believe all we need is a field where the user will provide the materialX file for an object. For exporting, we could add a button here or try to integrate the command as a menu entry in the File->export menu of Blender.
Design
Once we have a GUI that we know will allow us to perform all the steps in the most important stories, then we are ready to begin the software design stage. This is the stage that tends to freeze up those who are new at coding. Questions such as What functions do I need? Should I use classes? How do I structure my code? are important and it is at this stage that we will figure it out.
I always try to find a balance between how much design I do before I start exploratory coding. Why? well, based on my experience, no matter how much I design something, I almost always run into small issues in my design once I start developing. This could be due to how a certain API requires you to interact with it, or slight modifications on how data is returned from functions, etc.
When I design software I normally use Object Oriented Programming. Here is why I'm a big fan of Object Oriented Programming; having the ability to create your own custom data types which can perform custom actions and that co-relate to constructs in the real world is extremely useful and it can make programming so much easier once you wrap your head around how OOP works.
To design my classes I like to use a UML editor program to create a class diagram. There are tons of free tools available for performing this task. In the past, I have used UMLet and Violet UML. Now, full disclosure here. I am not a UML expert by any means. UML can be quite complex since it is designed to model all sorts of different interactions and scenarios. I only know what I really need to use, which is how to create class diagrams.
Exploratory Coding
Once you have built your design to the point that you feel you have covered all scenarios called out by the stories, it is time to dive into programming. But before I start writing the code for the application, I usually try to spot areas or procedures which might be new to me. This is one of the exciting things about software development, no matter how much you learn, you will always run into situations which might require a new way of doing things, or perhaps you need to use a 3rd party library that you have not used before.
I refer to this stage as exploratory coding. The goal here is not to code a complete solution, but instead, the goal is to get an understanding of how the unknown part of your application will behave. I have made the mistake in the past to charge right into development, only to find in the middle of the process that there is a portion that deals with things that I have not done before. I go ahead and figure out how to get it done, and several times, I have to go back and change a lot of my program, because the new solution does not really play well with how the rest of the program is structured.
Exploratory coding can be the most frustrating part and the most rewarding part. You are dealing with the unknown, trying to conjure up new solutions or figuring out how to connect different pieces to create a full machine.