This model provides the client with a computing platform including operating system and access to some software tools. The client gets a certain amount of work to do (modeling, debugging, or whatever they like to do), and is free to send the results back to their server or anywhere else they want to send. The client gets everything else in the software stack.
In a platform as a service model, the server has an equivalent computing resource on their side of the application as well. In this case, the client doesn’t have to transfer a work item to the server for the server to process it. Instead, the client could just send the work item to the server directly, and it would be processed immediately.
In short, with a platform as a service model, a client would be able to do all of their processing (any processing they want to do) directly from their platform.
High level overview
Let’s consider the advantages and disadvantages of this model for modelling, debugging and debugging.
These advantages of this model depend on the details of the platform used. The benefit of platform as a service is that it allows a developer to do any processing directly on the client side, and the server can help them do that processing in order to complete the logic they want to work with. It also means that if a developer needs to send multiple work items from their platform, and the first one gets sent but the second one takes longer than expected, the client doesn’t need to transfer anything from their platform back to the server. Instead, the server can just send the completed work item.
This model has some downsides. The downsides vary according to the implementation, but here are a few of the issues:
Limitations on input type validation, like an ID number, as in our example of validating some data in a service model. You could have some error checking in your platform, and the client could register a validator, but it’s difficult to find a validator that will actually work. In general, the developers would like the ability to check things from other platforms, as well.
With this model, you have to be careful to balance processing with input validation and validation of errors. If you don’t have proper validation of inputs, then your platform can be easily manipulated by someone on your team (or by someone with access to your server). The reason is that input validation can be done directly on your platform, and errors can be instantly added to a work item from your platform to the server. The other side of the equation is that there can be issues with data validation. If a piece of data is valid in your platform, and it’s verified to be valid in a different platform, then the validity of the work item won’t be guaranteed to be correct. So, the developer needs to perform the validation, and then take steps to verify the output of the validation. This can be a huge impediment to the debugging process.
One of the things I like about this model is the ability to send work items directly to the server. There are many situations where it would be handy to do that, and the server allows it. So, for example, if you needed to send a lot of code from a platform to another platform, then it could do that for you. One thing you can’t do is send a work item directly to another platform, and have it back in a format that works for both platforms. You have to make sure that the right data is sent, that the input validation is in place, that the validation codes are formatted correctly (like creating input, validating the input, copying the validation code into the input, and formatting the output) and so on.
Now that I’ve said that, I realize that it would be easy to send all of the code to the server and have it back to the client as a platform-specific application. That wouldn’t really make much sense, however. The problem with doing that is that the server may be going through a background task to generate something else for you (or maybe it’s telling the client that something else is happening on the server), and if you just have the client generate a new work item and send it directly to the server, then you won’t have proper validation. On the other hand, if the client makes its own platform-specific application and sends it directly to the server, then you would have very important validation validation that’s happening at the server level.
What do you think about this approach? Do you have any ideas or suggestions about improving this model? How would it be improved for you?