As the final installment of the Ics 314 software engineering course, we were asked by our professor to further analyze and explore the tools and fundamentals of software development and management through the use of issue driven project management. Issue driven project management once again is a culmination of several software development tools that in result provides a dynamic process for developing software. The project is contained within a file repository on a google projects hosting server which allows developers who want to contribute to the project access to the source and build files.
So in order to obtain a more “complete” understanding of the three prime directives of software development, our professor so graciously bestowed upon the task of building upon code that was not our own. In the last entry of this blog, we reviewed the code of another group, which in retrospect could be seen as the primer for this assignment, and to allow us some time to become familiar with the foreign source code. In all honesty, this was quite a difficult and time consuming task. For me personally, it takes a while to just adjust my thinking to be able to understand exactly what the author of the code is trying to accomplish. Writing code can really be seen as an art form, and takes a lot of concentration to logically draw out what needs to be built and how to organize this in a way that makes sense. If written sloppily or in a nonsensical way, it becomes quite difficult for another person to look at it and truly understand what the original author is trying to convey.
Luckily, the code that we received from our groups counter-part, for the most part was written quite well. There was a bit of added complexity to it because they had separated the control/main program into three hierarchal levels, which in result made it a little more difficult to understand and figure out where to implement the new commands. On the command level, they used an interface which works fine for the original commands because they all had the same input format, but to try and implement new commands that have different input formats starts to get a little more tricky. However, we did manage to find a work around to get the new commands to finally execute without disrupting the overall functioning of the program.
The aspect of working in a group on something like this, where the code is not your own adds another layer of difficulty. Not only are you dealing with unfamiliar code, but there is also a dependency of having other parts being completed by other people first before anything can be tested or run. I found this aspect of the project development the most troublesome, because there is only so much you can do up to a point where its starts to incur more code just to start testing the classes. The entire process of compiling and running and testing can also become quite frustrating and repetitive, because everything must be freshly compiled to include any changes that have been made.
In conclusion, there has been quite an exhaustive analysis of the three prime directives with this exercise; especially the third directive which pertains to the developer side of enhancing the system. It proved to be a much more difficult task due to the design of the program, and goes to show that it isn’t that easy to create modular code, or a product that others can easily interpret and understand. Although the ideal vision of the project management tool is to have developers be able to view the code in development and enhance the overall state of the project, like anything of considerable complexity that requires dedication and time to become proficient in, there is a learning curve; and what it boils down to is that person’s will to stay interested and learn the system in order to contribute
No comments:
Post a Comment