I’m reading Applying UML and Patterns and trying to match the OOA&D principles in there to a project I’ve worked on. It is kind of a retroactive learning exercise.
The project’s basic idea is to connect security alarms of various brands with generally similar behavior (although with significant differences) and distinct proprietary protocols to a (so far TCP) server or servers and control them via a mobile app (and also via a web application).
A basic “arm” command triggered by the phone starts a sequence of requests-responses between the server and the panel such as (for instance) check if a partition is already armed, bypass a number of its associated sensors as necessary (for example a defective sensor that keeps falsely signaling motion preventing the partition from arming), arm the partition, and check that it effectively armed; otherwise rollback (unbypass) the sensors if possible. A similar (no bypassing needed) case for “disarm the partition”, and so on (activate/deactivate a PGM output, open/close a gate, and various other devices that might be added).
If the arming fails, the app will report it and the user may want to take action (for example, she may have forgotten to set a sensor to be bypassed and decides to do it in the next arm).
Other features include a separate server for achieving the cameras’ streams/static pictures, and processing and forwarding the systems’ events to monitoring centers.
No rigorous OOA&D were applied; I’m trying to evaluate how much the project and the servers’ design would have been improved by applying it (writing use cases, modeling the domain, devising an architecture and designing the classes).
From what I understand, the use cases would have the end user as an actor interacting with the system (the mobile app) calling a REST API which by its turn sends a message to an external system (which is the TCP server or, indirectly, an intermediate message queue). A use case would be “arm the partition”.
I would then model the domain and when designing the TCP server, which is an external system, I would have another actor (the message queue or the message coming from the REST API’s implementation) issuing a similar “arm the partition” use case to that system. Its design would be based on the same domain model, with improvements coming from the experience of developing the server and figuring out the domain.
Do I understand correctly? Another question would be (not exactly looking for specific resources as that would be against the SE rules), what kind of knowledge should I seek in order to develop such a system in a ‘proper’ way?
A bonus question: iterative, agile methods attempt to mitigate risks by focusing on the most architecture-impacting, business valuable use cases. An future use case would be “automate/schedule command sequences or algorithms so that the user won’t have to manually send commands in a daily basis”. I see it as a very architecture-impacting use case, however it was not considered in the first iterations due to its complexity. What does agile dictate in that case in order to deal with the dilemma?
