forced_anon chat

Imagine this: you load up a 4chan chat page, and you're connected to another user to chat one on one. Completely at random, with no traces of identity whatsoever. That's it. There could be a button to get a new person if you really don't like who you're talking to or you've seen them before, or you could just hit F5. In the true spirit of Anonymous, you could talk about anything in complete freedom.

I think that could be pretty awesome (and also pretty fail, but such is the way of all things chan), and it's an idea that I've had in the back of my mind for a while. I don't have the wherewithal to make it happen, however, so by /img/'s recommendation I'm here pitching it to /prog/ in the hope that someone will get inspired and make this happen. I'd really like to see it made real. I have to imagine that it would be very simple to make, although finding a good host and getting people to use it is another matter.

Anyone's interest piqued?

>>1
That's a pretty amusing idea and easy enough to implement, too. You're wasting your time here, though, /prog/ never delivers anything, ever. I bet lots of people could hack something up in Python/Perl + Javascript real quick, post the code and let you handle the rest, like the actual CSS + HTML page layout. It's sad, really.

Only time I've seen anyone do something impressive for /prog/ was when one guy who was given random XOR encrypted files by the OP (who claimed they were Excel files) not only cracked them himself with only an hex editor and C programs he wrote himself, but also figured out what they really were. Everything else that /prog/ delivers is just 10 lines of Scheme or BBCode related programming jokes. And I'm not counting with the trolling and stupid memes you have to go through before you get meaningful replies either.

>>41
That's pretty impressive. I bet it was you, you suave bastard.

>>42
It was this thread:
http://dis.4chan.org/read/prog/1180036225

I'm not that guy, I'm not half of the expert programmer he is.

i bet it was you

>>41
Somehow, that doesn't surprise me. Well, I've never written anything intended to function like a server before, so I'm not entirely sure where to begin. You mention python and perl, neither of which I'm familiar with, but would PHP do the job? I really ought to figure out this whole AJAX thing, especially since I'm already reasonably familiar with javascript. I don't think that's going to be a problem, but what will be is my unfamiliarity with writing code that... needs each of its instances to be in some aware of each other.

If I had to cobble something together, I suppose I'd have a function that checked a text file on the server for a unique ID and either grabbed it if it was there and wiped the file, or set its own to be grabbed on next run. Then I'd have another file to act as a kind of message board to be checked by each instance of the script for messages addressed to its own ID (the first of which would be an indication to the instance whose ID was grabbed that it had been paired up). Using text files is probably ridiculous, and maybe the entire concept is too, but that ought to illustrate my understanding (or lack thereof). Can anyone point me in the right direction?

I think if I were to implement this I'd set it up so that anons telnetted into a server that would pair up two random anons for chatting. When they typed, the characters would be echoed to a shared buffer in real time (control codes filtered out, of course).

it's not so simple to do this, because you need to use asynchronous javascript and xml or something else besides plain javascript to chat in a webpage, since webpages... they're... you know... stateless.

>>46
I kind of want to learn Erlang and then do this. I've been looking for an excuse to learn Erlang.
I hate webdev though. Fuck that.

>>48
Erlang is awesome. Too bad I'm not proficient yet.
-module( server ).
-export( [ start/1, responder/1, listen/2, client/2, client_get_name/2 ] ).

start( Port )
    ->
    % Start up the responder so messages can get sent to it.
    PID_Responder = spawn( server, responder, [ [] ] ),
   
    % Make sure shit works
    PID_Responder ! { print_message, "Responder created!~n" },
   
    % Create the server socket and start the server
    case gen_tcp:listen( Port, [ list, { active, false }, { packet, line } ] ) of
        { ok, ServSock }
            ->
            { ok, Port } = inet:port( ServSock ),
            io:format( "Listening on port ~w.~n", [ Port ] ),
            listen( ServSock, PID_Responder );
        { error, Reason }
            ->
            { error, Reason }
    end.
   
listen( ServerSock, PID_Responder )
    ->
    % Grab the client attempting to connect
    case gen_tcp:accept( ServerSock ) of
        { ok, ClientSock }
            ->
            io:format( "Client connected!~n", [] ),
           
            % Send message to responder
            PID_Responder ! { new_client, ClientSock },
           
            % Continue listening.
            listen( ServerSock, PID_Responder );
           
        Other
            ->
            io:format( "gen_tcp:accept returned ~p. Quitting.~n", [ Other ] )
    end
    .
   
client( { ClientSock, ClientName }, PID_Responder )
    ->   
    % Just wait for something to happen.
    case gen_tcp:recv( ClientSock, 0 ) of
        { ok, RawMsg }    
            ->
            Msg = io_lib:format( "~s", [ RawMsg ] ),
            io:format( "~s sent message: ~s", [ ClientName, Msg ] ),
            PID_Responder ! {
                client_message,
                io_lib:format(
                    "<~s> ~s",
                    [ ClientName, Msg ]
                )
            },
            client( { ClientSock, ClientName }, PID_Responder );
        { error, closed }
            ->
            io:format( "~s disconnected.", [ ClientName ] ),
            PID_Responder ! { client_closed, { ClientSock, ClientName } }
    end
    .

client_get_name( ClientSock, PID_Responder )
    ->
    % Send the request.
    gen_tcp:send( ClientSock, "Enter username: " ),
   
    % Get it back.
    case gen_tcp:recv( ClientSock, 0 ) of
        { ok, ClientName }
            ->
            { _, StrippedClientName1, _ } =
                regexp:sub(
                    ClientName,
                    "^[ \t\r\n]*",
                    ""
                ),
           
            { _, StrippedClientName, _ } =
                regexp:sub(
                    StrippedClientName1,
                    "[ \t\r\n]*$",
                    ""
                ),
           
            PID_Responder ! { client_choose_name, { ClientSock, StrippedClientName } };
        { error, _ }
            ->
            io:format( "Unable to get client name.~n", [] ),
            io:format( "Client disconnected.~n", [] )
    end
    .

% This could be better implemented with a high-order fun + lists:foreach
send_to_all_clients( [ { ClientSock, _ } | Rest ], Msg )
    ->
    gen_tcp:send( ClientSock, Msg ),
    send_to_all_clients( Rest, Msg );
   
send_to_all_clients( [], _ )
    ->
    ok
    .

responder( ClientList )
    ->
    % Message handler
    receive
        { print_message, Message }
            ->
            % Just print the message...
            io:format( Message, [] ),
           
            % Loop
            responder( ClientList );
       
        { new_client, ClientSock }
            ->
            % Spawn a new thread for this client, attempt to get name
            spawn( server, client_get_name, [ ClientSock, self() ] ),
       
            % Loop
            responder( ClientList );
       
        { client_choose_name, { ClientSock, ClientName } }
            ->
            % Make sure the name isn't taken.
            case lists:keysearch( ClientName, 2, ClientList ) of
                false
                    ->
                    % Add the client into the list
                    NewClientList = [ { ClientSock, ClientName } | ClientList ],
           
                    % Send the join message to all users
                    send_to_all_clients(
                        NewClientList,
                        io_lib:format(
                            "~s has joined the chat.~n",
                            [ ClientName ]
                        )
                    ),
                   
                    % Set up the thread to listen for that client
                    spawn( server, client,
                        [ { ClientSock, ClientName }, self() ]
                    ),
                   
                    % Loop with new client list.
                    responder( NewClientList );
                   
                { value, _ }
                    ->
                    % Send them a message
                    gen_tcp:send( ClientSock,
                        io_lib:format(
                            "The name ~s is already taken.~n",
                            [ ClientName ]
                        )
                    ),
                   
                    % Request they choose another name
                    spawn( server, client_get_name, [ ClientSock, self() ] ),
           
                    % Loop with old client list.
                    responder( ClientList )
            end;
           
            % Already looped above.
       
        { client_message, Msg }
            ->
            % Message is preformatted.
           
            % Need to send the message to all clients.
            send_to_all_clients( ClientList, Msg ),
       
            % Loop
            responder( ClientList );
       
        { client_closed, { ClientSock, ClientName } }
            ->
            % Remove the entry from the list, if it exists.
            NewClientList = lists:keydelete( ClientSock, 1, ClientList ),
           
            % Send message to all clients about logoff.
            send_to_all_clients(
                NewClientList,
                io_lib:format( "~s has left the chat.~n", [ ClientName ] )
            ),
       
            % loop
            responder( NewClientList )
    end
    .

>>37
The problem with "wave(s) of the future" languages, is that they never are. And then five years down the road, they're just the "wave of fail that was ENTERPRISE GRADE five years ago". Languages like, lisp, C, etc... have been around oh... 30 years? And are still used.

ONE WORD. JAVA

>>49
Wow, awesome. Too bad that was actually the easiest part of it and (as usual with toy languages) your example is completely worthless in the real world.

>>52
haha o wow. The telecommunications industry relies on Erlang.

>>50
Languages like, lisp, C, etc... have been around oh... 30 years? And are still used.
Right. Only thing is, nobody uses LISP.

>>53
Hahahaha oh wow. Actually, the point still stands and one company isn't the telecommunications industry. Shows what you know, though.

>>55
Let's see your version of the same application in C. I'm willing to bet that it's a fuckload more convoluted than Erlang, and that's just the easiest part of the application. Thanks.

To add to this, let's see you perform runtime code-patching in anything but a "toy" language. Enjoy your measly uptimes measured in mere weeks, and your system-wide crashes when a single server fails while my language ensures that my application can stay running on my cluster with it's built-in process redundancy and error recovery systems.

Sorry if you're not used to thinking in such large-scale terms.

>>56
LOL @ comparing it to C

Is that all you got, unemployed toyfag?

>>57
Let's see you do something actually useful, you moron.

>>57
Why hello thar I am an Enterprise Programmer. I do not need to know how to design stable programs, my toy language does it automagically for me.
Fix'd, Visual Basic thinking spotted. GTFO my /prog/

>>41
That was me, thanks for the compliment.

http://www.erlang-projects.org/Public/success_stories/commercial_use/view

>>61
Hilarious. And most of those 10 entries aren't even actual projects or products.

"IDEALX mentions Erlang along with Perl and Python in its Guide of Open Source Software. (...)"
Oh wow.

So, has anyone written the program yet?

>>63
Yep, I'm not sharing though, it's too much fun talking to myself.

>>63
Nobody's going to write your stupid program.

Also, the idea is fucking retarded. Why would I want to chat one-on-one with some faggot /b/tard?

>>58
Is that all you got, self-hating Java fag?

>>63
Not OP.

>>65
The idea is that they wouldn't BE some faggot /b/tard when you stripped away that context and, hopefully, that identity along with it.

>>67
You haven't talked to a lot of /b/tards outside of /b/, have you?

>>68

I've talked to myself before

>>68
I know a lot of /b/tards IRL, and besides a weirder sense of humor they're pretty much regular boys and girls.

The one on one part is what makes this fail. Just make it a regular chat where everyone is named Anonymous unless they use a name and/or tripcode, like on the boards.

>>71
But then it's just like any thread on the board, except with faster spamming.

>>70
_{^{they're pretty much regular boys and girls.}
regular boys and girls.}
boys and girls.
girls

>>73
with a penis

>>74
no, no, without penis. really. I've checked.

>>71
No, see it's when you get more than 2 in a room that you start to have problems. They just start copying each other and spouting the same old shit in an attempt to prove to each other that their members of the cool kids' club. Names/tripcodes only provide them with identities and make the matter worse. But with two people there's only 'me' and 'you,' and there's no sense of a group to belong to.

But what if an odd number of people are connected? Does the odd man just wait until someone else connects, or quit before that happens?

>>77
Right, he'd have to wait. Hopefully there'd be enough users that the wait would be short.

>>77
I'd suggest randomly putting him into a chat session with two others, then removing one random person and putting him into a one-to-one with someone else when they connect. Should be interesting.

I think chats should only be a minute long, then you move along. like that dance where people swap partners. i saw it in a movie.