Ever find yourself questioning exactly how application
development works? It's quite a process, but it's not actually all that hard to
understand. Like everything else, though, there are two competing schools of
thought, but neither is very hard to follow.
Ever find yourself wondering exactly how application
development works? It's quite a process, but it's not actually all that hard to
understand. Like everything else, though, there are two competing schools of
thought, but neither is very hard to follow.
With older languages like C++ that combine object oriented design with more
traditional programming methods, first an end goal is decided. Something like
"I want a piece of software that does X while not Y." Next, a design
document that covers every single little intended detail is produced.
Afterward, the design document is handed off to the programmers for coding.
Basic debugging follows coding, and the application is then passed off for
testing. Once all the kinks are worked out, it's time to ship the final
product, basically, anyway.
It gets interesting when you look at the new school of thought. Newer languages
like Java allow for a methodology that still works to an overall goal, but
technicalities in the language allow for a more exploratory approach that
doesn't require quite an extensive design document and nothing is set in stone.
Pieces of the program are built separately with a sort of "promise"
to fulfill a role - even though the pieces and programmers thereof may have no
idea how the others will do it. It works because each piece is far more
optimal, and can be debugged, streamlined, or expanded independently to meet
newly discovered needs. What follows is just like the above: debug, test, fix,
and ship... and that's it in a nutshell.
