CareerCup

I think that a good answer is to send the length of the string in bytes (coded for example as a 4 bytes unsigned integer) followed by the list of bytes, one per char.

The receiver reads the first 4 bytes and understand the string length (let says L), then it reads the following L bytes and build the string.

Here we are assuming that the string is ASCII encoded, so we don't need any other information.

Anyway for completeness, we can encode also the string encoding(ASCII, UTF8, UTF16, ISO*, etc...) using for instance an extra byte after the string length field. In this case the reader reads 4 bytes for the length, 1 byte for the encoding and L bytes for the content. Depending on the encoding the receiver can interpret correctly the string content.

With the help of serialization n Data conversion in form of Byte stream u can send data on network .

"how do you escape characters in a string"
He probably was looking for some compression/ coding technique and serialization technique. Not sure .. you should have asked more questions, I usually ask more questions because sometimes the answer evolves out of the details of the question

The question is: if you send a bunch of bytes over the network, how do you differentiate between the data (string) and the metadata (description of the data like number of bytes to expect), so the receiver can get the data.

One answer would be to use messages with header + body.

are they talking about serialize the data using xml

In context of socket programming, i would say he added hint of escape character because we stop reading when we encounter one...i am not sure how to send such an information over network now..

use the method getBytes() of the String class to serialize the string
byte b[]=new String().getBytes();

I would use bytes too. In the context of serialization, your protocol would have to on agree on:
1) How many bytes to read in (either a byte-count or a sentinel is common)
2) What character each unique byte maps to

Since there are 256 valid characters, we couldn't use a sentinel without using 9 bits to represent the data, since 8 bits would mean we couldn't tell a sentinel apart from the data itself. Might as well use a byte count instead.

On the serialization end of things you would send a number indicating the number of bytes (characters) to read in, followed by each character mapped to its byte representation. On the deserialization end, keep reading bytes and mapping them to characters up to the number given.

The poster haven't understood the question at all which means that he hasn't volunteered to ask any question to the interviewer. Goes a long way to say how he would have fared in the interview.

Here's your answer: The basic idea is that you need to be able to represent any of the characters in the data while also using those same characters to mark the end of a string. You do this by using an escape sequence. For example, the stream sees "\0" and knows that the string is terminated and a new one comes next. The final problem is then how to represent a backslash in the actual string, which can simply be "\\".

The reason this is important in serialization is because a stream of data is one continuous flow of bytes. There is no notion of new lines or boundaries between objects until you explicitly code such boundaries in there.

Here is an example Pythonic pseudocode implementation:

def write(str, stream):
	for char in str:
		# doesn't check for double back slash, just checks for back slash,
		# since Python has escape sequences too
		if char == '\\':
			stream.write(char) # write an extra backslash
		stream.write(char)
	
	# write escape sequence in stream to indicate end
	stream.write('\\')
	stream.write('0')

I guess he was asking you to compress the string! huffman encoding/decoding might be possible anwers