Task: Binary strings
C++: #include <iomanip>
#include <iostream>

using namespace std;

string replaceFirst(string &s, const string &target, const string &replace) {
    auto pos = s.find(target);
    if (pos == string::npos) return s;
    return s.replace(pos, target.length(), replace);
}

int main() {

    
    string x = "hello world";

    
    x = "";

    
    x = "ab\0";
    cout << x << '\n';
    cout << x.length() << '\n';

    
    if (x == "hello") {
        cout << "equal\n";
    } else {
        cout << "not equal\n";
    }
    if (x < "bc") {
        cout << "x is lexigraphically less than 'bc'\n";
    }

    
    auto y = x;
    cout << boolalpha << (x == y) << '\n';
    cout << boolalpha << (&x == &y) << '\n';

    
    string empty = "";
    if (empty.empty()) {
        cout << "String is empty\n";
    }

    
    x = "helloworld";
    x += (char)83;
    cout << x << '\n';

    
    auto slice = x.substr(5, 5);
    cout << slice << '\n';

    
    auto greeting = replaceFirst(x, "worldS", "");
    cout << greeting << '\n';

    
    auto join = greeting + ' ' + slice;
    cout << join << '\n';

    return 0;
}

Java: module BinaryStrings
    {
    @Inject Console console;
    void run()
        {
        Byte[] mutableBytes = new Byte[];       
        Byte[] fixedLength  = new Byte[10];     
        Byte[] literal      = [0, 1, 7, 0xff];  
        console.print($|String creation and assignment:
                       |  mutableBytes={mutableBytes}
                       |  fixedLength={fixedLength}
                       |  literal={literal}
                       |
                     );

        console.print($|Check if a string is empty:
                       |  mutableBytes.empty={mutableBytes.empty}
                       |  fixedLength.empty={fixedLength.empty}
                       |  literal.empty={literal.empty}
                       |
                     );

        mutableBytes += 0;                      
        mutableBytes.add(1);                    
        mutableBytes.addAll(#07FF);             
        console.print($|Append a byte to a string:
                       |  mutableBytes={mutableBytes}
                       |
                     );

        console.print($|String comparison:
                       |  mutableBytes==literal = {mutableBytes==literal}
                       |  fixedLength==literal = {fixedLength==literal}
                       |
                     );

        fixedLength = new Byte[4](i -> literal[i]);     
        val clone = fixedLength.clone();                
        console.print($|String cloning and copying:
                       |  fixedLength={fixedLength}
                       |  clone={clone}
                       |
                     );

        console.print($|Extract a substring from a string:
                       |  mutableBytes[1..2]={mutableBytes[1..2]}
                       |  fixedLength[0..2]={fixedLength[0..2]}
                       |  literal[2..3]={literal[2..3]}
                       |
                     );

        for (Int start = 0; Int index := fixedLength.indexOf(0x01, start); start = index)
            {
            fixedLength[index] = 0x04;
            }
        console.print($|Replace every occurrence of a byte in a string with another string:
                       |  fixedLength={fixedLength}
                       |
                     );

        for (Int start = 0; Int index := mutableBytes.indexOf(#0107, start); start = index)
            {
            mutableBytes.replaceAll(index, #9876);
            }
        console.print($|Replace every occurrence of a string in a string with another string:
                       |  mutableBytes={mutableBytes}
                       |
                     );

        console.print($|Join strings:
                       |  mutableBytes+fixedLength+literal={mutableBytes+fixedLength+literal}
                       |
                     );
        }
    }