In software design, we usually take care of UML diagrams and architecture design.

But in case of a data analysis software, we must pay attention to design algorithms and stuff like that. Consider the case of a face detection software which needs AI. Do we need to design AI part of the software explicitly in software design?

P.S: My manager says that it must set clear in feasibility study and be so clear that we could design it in design steps. Is he correct?

  • 3
    Sharing your research helps everyone. Tell us what you've tried and why it didn’t meet your needs. This demonstrates that you’ve taken the time to try to help yourself, it saves us from reiterating obvious answers, and most of all it helps you get a more specific and relevant answer. Also see How to Ask – gnat Mar 12 '14 at 7:37
  • @gnat I updated the question, hope it be clear now. – Mehraban Mar 12 '14 at 7:56
  • 1
    Sam, your question is still unclear. UML does not equal software design. – Deer Hunter Mar 12 '14 at 8:02
  • Now I am going to wonder if it is on topic! @DeerHunter – Mehraban Mar 12 '14 at 8:03
  • 1
    Sam, it looks like it is, but please clarify what your problem is. – Deer Hunter Mar 12 '14 at 8:05

From my experience, it is better to start with the algorithm itself. Analyze the algorithm, find out what data flows it requires, what data structures should be used, etc. This approach enables you to build the software around the most complex part of it and thus foresee and manage the risks associated with it. This will also help make implementation easier and more optimal.

If an algorithm is in a separate [independent] module, such analysis could be done after the high-level architecture is developed. But still the analysis should be completed before any decisions regarding implementation are made.

Side Note: Pay special attention on choosing the data structures that the algorithm will work with. Data structures can hide some of the complexity inside them thus making the implementation more maintainable.


All algorithmical parts, especially such of higher complexity, should be well encapsulated behind a deliberately designed API. This will dramatically increase decoupling, which is one of the core design principles, IMHO.

Consequently, the algorithm needs to be designed as detailed as necessary, such that this API becomes a clear enough shape to put it into the overall picture and further changes to that API will be minimized.

You want to minimize risk while reducing the initial efforts, which is more or less a tradeoff in which you have to find the optimal balance point. You can't completely eliminate the risk of further API changes in that stage, but you can strive to avert avoidable mistakes and reduce the impact of such changes as much as possible.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.