Best way to do interprocess communication on Mac OS X

by

I am currently looking into the same questions. For me the possibility of adding Windows clients later makes the situation more complicated; in your case the answer seems to be simpler.

About the options you have considered:

  1. Control files: While it is possible to communicate via control files, you have to keep in mind that the files need to be communicated via a network file system among the machines involved. So the network file system serves as an abstraction of the actual network infrastructure, but does not offer the full power and flexibility the network normally has. Implementation: Practically, you will need to have at least two files for each pair of client/servers: a file the server uses to send a request to the client(s) and a file for the responses. If each process can communicate both ways, you need to duplicate this. Furthermore, both the client(s) and the server(s) work on a “pull” basis, i.e., they need to revisit the control files frequently and see if something new has been delivered.

    The advantage of this solution is that it minimizes the need for learning new techniques. The big disadvantage is that it has huge demands on the program logic; a lot of things need to be taken care of by you (Will the files be written in one piece or can it happen that any party picks up inconsistent files? How frequently should checks be implemented? Do I need to worry about the file system, like caching, etc? Can I add encryption later without toying around with things outside of my program code? …)

    If portability was an issue (which, as far as I understood from your question is not the case) then this solution would be easy to port to different systems and even different programming languages. However, I don’t know of any network files ystem for iPhone OS, but I am not familiar with this.

  2. Sockets: The programming interface is certainly different; depending on your experience with socket programming it may mean that you have more work learning it first and debugging it later. Implementation: Practically, you will need a similar logic as before, i.e., client(s) and server(s) communicating via the network. A definite plus of this approach is that the processes can work on a “push” basis, i.e., they can listen on a socket until a message arrives which is superior to checking control files regularly. Network corruption and inconsistencies are also not your concern. Furthermore, you (may) have more control over the way the connections are established rather than relying on things outside of your program’s control (again, this is important if you decide to add encryption later on).

    The advantage is that a lot of things are taken off your shoulders that would bother an implementation in 1. The disadvantage is that you still need to change your program logic substantially in order to make sure that you send and receive the correct information (file types etc.).

    In my experience portability (i.e., ease of transitioning to different systems and even programming languages) is very good since anything even remotely compatible to POSIX works.

    [EDIT: In particular, as soon as you communicate binary numbers endianess becomes an issue and you have to take care of this problem manually – this is a common (!) special case of the “correct information” issue I mentioned above. It will bite you e.g. when you have a PowerPC talking to an Intel Mac. This special case disappears with the solution 3.+4. together will all of the other “correct information” issues.]

  3. +4. Distributed objects: The NSProxy class cluster is used to implement distributed objects. NSConnection is responsible for setting up remote connections as a prerequisite for sending information around, so once you understand how to use this system, you also understand distributed objects. ;^)

    The idea is that your high-level program logic does not need to be changed (i.e., your objects communicate via messages and receive results and the messages together with the return types are identical to what you are used to from your local implementation) without having to bother about the particulars of the network infrastructure. Well, at least in theory. Implementation: I am also working on this right now, so my understanding is still limited. As far as I understand, you do need to setup a certain structure, i.e., you still have to decide which processes (local and/or remote) can receive which messages; this is what NSConnection does. At this point, you implicitly define a client/server architecture, but you do not need to worry about the problems mentioned in 2.

    There is an introduction with two explicit examples at the Gnustep project server; it illustrates how the technology works and is a good starting point for experimenting:
    http://www.gnustep.org/resources/documentation/Developer/Base/ProgrammingManual/manual_7.html

    Unfortunately, the disadvantages are a total loss of compatibility (although you will still do fine with the setup you mentioned of Macs and iPhone/iPad only) with other systems and loss of portability to other languages. Gnustep with Objective-C is at best code-compatible, but there is no way to communicate between Gnustep and Cocoa, see my edit to question number 2 here: CORBA on Mac OS X (Cocoa)

    [EDIT: I just came across another piece of information that I was unaware of. While I have checked that NSProxy is available on the iPhone, I did not check whether the other parts of the distributed objects mechanism are. According to this link: http://www.cocoabuilder.com/archive/cocoa/224358-big-picture-relationships-between-nsconnection-nsinputstream-nsoutputstream-etc.html (search the page for the phrase “iPhone OS”) they are not. This would exclude this solution if you demand to use iPhone/iPad at this moment.]

So to conclude, there is a trade-off between effort of learning (and implementing and debugging) new technologies on the one hand and hand-coding lower-level communication logic on the other. While the distributed object approach takes most load of your shoulders and incurs the smallest changes in program logic, it is the hardest to learn and also (unfortunately) the least portable.

More Related Contents:

  1. How to get pixel data from a UIImage (Cocoa Touch) or CGImage (Core Graphics)?
  2. Cocoa: What’s the difference between the frame and the bounds?
  3. Core Data vs SQLite 3 [closed]
  4. Programming P2P application
  5. When is TCP option SO_LINGER (0) required?
  6. Formatting NSDate into particular styles for both year, month, day, and hour, minute, seconds
  7. Basic Python client socket example
  8. Why can’t code inside unit tests find bundle resources?
  9. IPC performance: Named Pipe vs Socket
  10. Cocoa Keyboard Shortcuts in Dialog without an Edit Menu
  11. Sending a reset in TCP/IP Socket connection
  12. Get NSTextField contents to scale
  13. How well is Objective-C++ supported?
  14. C# Begin/EndReceive – how do I read large data?
  15. Not being able to edit NSTextField on NSPopover even though Editable behavior is set
  16. Deep copy of dictionaries gives Analyze error in Xcode 4.2
  17. NSURL URLWithString: is null with non-english accented characters
  18. Programmatically check if a process is running on Mac
  19. Widget “flip” behavior in Core Animation/Cocoa
  20. using dispatch_sync in Grand Central Dispatch
  21. Proper way to stop TcpListener
  22. How to reset a socket back to blocking mode (after I set it to nonblocking mode)?
  23. Java TCP socket: data transfer is slow
  24. Can I add my own code snippets to xcode 4?
  25. Releasing bound ports on process exit
  26. Understanding htonl() and ntohl()
  27. Sockets On Same Machine For Windows and Linux
  28. passing a struct over TCP (SOCK_STREAM) socket in C
  29. Key-Value-Observing a to-many relationship in Cocoa
  30. NSDate between two given NSDates

Leave a Comment