//  Hello World server

#include <zmq.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>

int main (void)
{
    //  Socket to talk to clients
    void *context = zmq_ctx_new ();
    void *responder = zmq_socket (context, ZMQ_REP);
    int rc = zmq_bind (responder, "tcp://*:5555");
    assert (rc == 0);

    while (1) {
        char buffer [10];
        zmq_recv (responder, buffer, 10, 0);
        printf ("Received Hello\n");
        sleep (1);          //  Do some 'work'
        zmq_send (responder, "World", 5, 0);
    }
    return 0;
}

//
//  Hello World server in C++
//  Binds REP socket to tcp://*:5555
//  Expects "Hello" from client, replies with "World"
//
#include <zmq.hpp>
#include <string>
#include <iostream>
#ifndef _WIN32
#include <unistd.h>
#else
#include <windows.h>

#define sleep(n)	Sleep(n)
#endif

int main () {
    //  Prepare our context and socket
    zmq::context_t context (2);
    zmq::socket_t socket (context, zmq::socket_type::rep);
    socket.bind ("tcp://*:5555");

    while (true) {
        zmq::message_t request;

        //  Wait for next request from client
        socket.recv (request, zmq::recv_flags::none);
        std::cout << "Received Hello" << std::endl;

        //  Do some 'work'
        sleep(1);

        //  Send reply back to client
        zmq::message_t reply (5);
        memcpy (reply.data (), "World", 5);
        socket.send (reply, zmq::send_flags::none);
    }
    return 0;
}

;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
;;;
;;;  Hello World server in Common Lisp
;;;  Binds REP socket to tcp://*:5555
;;;  Expects "Hello" from client, replies with "World"
;;;
;;; Kamil Shakirov <kamils80@gmail.com>
;;;

(defpackage #:zguide.hwserver
  (:nicknames #:hwserver)
  (:use #:cl #:zhelpers)
  (:export #:main))

(in-package :zguide.hwserver)

(defun main ()
  ;; Prepare our context and socket
  (zmq:with-context (context 1)
    (zmq:with-socket (socket context zmq:rep)
      (zmq:bind socket "tcp://*:5555")

      (loop
        (let ((request (make-instance 'zmq:msg)))
          ;; Wait for next request from client
          (zmq:recv socket request)
          (message "Received request: [~A]~%"
                   (zmq:msg-data-as-string request))

          ;; Do some 'work'
          (sleep 1)

          ;; Send reply back to client
          (let ((reply (make-instance 'zmq:msg :data "World")))
            (zmq:send socket reply))))))

  (cleanup))

#! /usr/bin/env escript

%% Starts a local hello server.
%% Binds to tcp://localhost:5555

main(_Args) ->
    application:start(chumak),
    {ok, Socket} = chumak:socket(rep, "my-rep"),
    {ok, _Pid} = chumak:bind(Socket, tcp, "localhost", 5555),
    loop(Socket).

loop(Socket) ->
    {ok, RecvMessage} = chumak:recv(Socket),
    io:format("Received request : ~p\n", [RecvMessage]),

    timer:sleep(1000),

    chumak:send(Socket, "World"),
    loop(Socket).

defmodule Hwserver do
  @moduledoc """
  Generated by erl2ex (http://github.com/dazuma/erl2ex)
  From Erlang source: (Unknown source file)
  At: 2019-12-20 13:57:24

  """

  def main(_) do
    IO.puts("hwserver starting")
    {:ok, context} = :erlzmq.context()
    {:ok, responder} = :erlzmq.socket(context, :rep)
    :ok = :erlzmq.bind(responder, 'tcp://*:5555')
    loop(responder)
    :ok = :erlzmq.close(responder)
    :ok = :erlzmq.term(context)
  end


  def loop(responder) do
    {:ok, msg} = :erlzmq.recv(responder)
    :io.format('Received ~s~n', [msg])
    :timer.sleep(1000)
    :ok = :erlzmq.send(responder, "World")
    loop(responder)
  end

end

Hwserver.main(:ok)

//
// Hello World Zeromq server
//
// Author: Aaron Raddon   github.com/araddon
// Requires: http://github.com/alecthomas/gozmq
//
package main

import (
	"fmt"
	zmq "github.com/alecthomas/gozmq"
	"time"
)

func main() {
	context, _ := zmq.NewContext()
	socket, _ := context.NewSocket(zmq.REP)
	defer context.Close()
	defer socket.Close()
	socket.Bind("tcp://*:5555")

	// Wait for messages
	for {
		msg, _ := socket.Recv(0)
		println("Received ", string(msg))

		// do some fake "work"
		time.Sleep(time.Second)

		// send reply back to client
		reply := fmt.Sprintf("World")
		socket.Send([]byte(reply), 0)
	}
}

{-# LANGUAGE OverloadedStrings #-}

-- Hello World server

module Main where

import Control.Concurrent
import Control.Monad
import System.ZMQ4.Monadic

main :: IO ()
main = runZMQ $ do
    -- Socket to talk to clients
    responder <- socket Rep
    bind responder "tcp://*:5555"

    forever $ do
        buffer <- receive responder
        liftIO $ do
            putStrLn "Received Hello"
            threadDelay 1000000 -- Do some 'work'
        send responder [] "World"

package ;
import haxe.io.Bytes;
import neko.Lib;
import neko.Sys;
import org.zeromq.ZMQ;
import org.zeromq.ZMQContext;
import org.zeromq.ZMQException;
import org.zeromq.ZMQSocket;

/**
 * Hello World server in Haxe
 * Binds REP to tcp://*:5556
 * Expects "Hello" from client, replies with "World"
 * Use with HelloWorldClient.hx
 * 
 */
class HelloWorldServer 
{

	public static function main() {
		
		var context:ZMQContext = ZMQContext.instance();
		var responder:ZMQSocket = context.socket(ZMQ_REP);

		Lib.println("** HelloWorldServer (see: https://zguide.zeromq.cn/page:all#Ask-and-Ye-Shall-Receive)");

		responder.setsockopt(ZMQ_LINGER, 0);
		responder.bind("tcp://*:5556");
		
		try {
			while (true) {
				// Wait for next request from client
				var request:Bytes = responder.recvMsg();
				
				trace ("Received request:" + request.toString());
				
				// Do some work
				Sys.sleep(1);
				
				// Send reply back to client
				responder.sendMsg(Bytes.ofString("World"));
			}
		} catch (e:ZMQException) {
			trace (e.toString());
		}
		responder.close();
		context.term();
		
	}
	
}

package guide;

//
//  Hello World server in Java
//  Binds REP socket to tcp://*:5555
//  Expects "Hello" from client, replies with "World"
//

import org.zeromq.SocketType;
import org.zeromq.ZMQ;
import org.zeromq.ZContext;

public class hwserver
{
    public static void main(String[] args) throws Exception
    {
        try (ZContext context = new ZContext()) {
            // Socket to talk to clients
            ZMQ.Socket socket = context.createSocket(SocketType.REP);
            socket.bind("tcp://*:5555");

            while (!Thread.currentThread().isInterrupted()) {
                byte[] reply = socket.recv(0);
                System.out.println(
                    "Received " + ": [" + new String(reply, ZMQ.CHARSET) + "]"
                );

                Thread.sleep(1000); //  Do some 'work'

                String response = "world";
                socket.send(response.getBytes(ZMQ.CHARSET), 0);
            }
        }
    }
}

#!/usr/bin/env julia

#
# Hello World server in Julia
# Binds REP socket to tcp://*:5555
# Expects "Hello" from client, replies "World"
#

using ZMQ

context = Context()
socket = Socket(context, REP)
ZMQ.bind(socket, "tcp://*:5555")

while true
    # Wait for next request from client
    message = String(ZMQ.recv(socket))
    println("Received request: $message")

    # Do some 'work'
    sleep(1)

    # Send reply back to client
    ZMQ.send(socket, "World")
end

# classy hit men always clean up when finish the job.
ZMQ.close(socket)
ZMQ.close(context)

--
--  Hello World server
--  Binds REP socket to tcp://*:5555
--  Expects "Hello" from client, replies with "World"
--
--  Author: Robert G. Jakabosky <bobby@sharedrealm.com>
--
require"zmq"
require"zhelpers"

local context = zmq.init(1)

--  Socket to talk to clients
local socket = context:socket(zmq.REP)
socket:bind("tcp://*:5555")

while true do
    --  Wait for next request from client
    local request = socket:recv()
    print("Received Hello [" .. request .. "]")

    --  Do some 'work'
		s_sleep(1000)

    --  Send reply back to client
    socket:send("World")
end
--  We never get here but if we did, this would be how we end
socket:close()
context:term()

// Hello World server
// Binds REP socket to tcp://*:5555
// Expects "Hello" from client, replies with "world"

var zmq = require('zeromq');

// socket to talk to clients
var responder = zmq.socket('rep');

responder.on('message', function(request) {
  console.log("Received request: [", request.toString(), "]");

  // do some 'work'
  setTimeout(function() {

    // send reply back to client.
    responder.send("World");
  }, 1000);
});

responder.bind('tcp://*:5555', function(err) {
  if (err) {
    console.log(err);
  } else {
    console.log("Listening on 5555...");
  }
});

process.on('SIGINT', function() {
  responder.close();
});

//
//  Hello World server
//  Binds REP socket to tcp://*:5555
//  Expects "Hello" from client, replies with "World"
//
#import <Foundation/Foundation.h>
#import "ZMQObjc.h"

int
main(void)
{
	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
	ZMQContext *ctx = [[[ZMQContext alloc] initWithIOThreads:1U] autorelease];

	/* Get a socket to talk to clients. */
	static NSString *const kEndpoint = @"tcp://*:5555";
	ZMQSocket *responder = [ctx socketWithType:ZMQ_REP];
	BOOL didBind = [responder bindToEndpoint:kEndpoint];
	if (!didBind) {
		NSLog(@"*** Failed to bind to endpoint [%@].", kEndpoint);
		return EXIT_FAILURE;
	}

	for (;;) {
		/* Create a local pool so that autoreleased objects can be disposed of
		 * at the end of each go through the loop.
		 * Otherwise, memory usage would continue to rise
		 * until the end of the process.
		 */
		NSAutoreleasePool *localPool = [[NSAutoreleasePool alloc] init];

		/* Block waiting for next request from client. */
		NSData *request = [responder receiveDataWithFlags:0];
		NSString *text = [[[NSString alloc]
				initWithData:request encoding:NSUTF8StringEncoding] autorelease];
		NSLog(@"Received request: %@", text);

		/* "Work" for a bit. */
		sleep(1);

		/* Send reply back to client. */
		static NSString *const kWorld = @"World";
		const char *replyCString = [kWorld UTF8String];
		const NSUInteger replyLength = [kWorld
				lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
		NSData *reply = [NSData dataWithBytes:replyCString length:replyLength];
		[responder sendData:reply withFlags:0];

		[localPool drain];
	}

	/* Close the socket to avoid blocking in -[ZMQContext terminate]. */
	[responder close];
	/* Dispose of the context and socket. */
	[pool drain];
	return EXIT_SUCCESS;
}

# Hello World server in Perl

use strict;
use warnings;
use v5.10;

use ZMQ::FFI;
use ZMQ::FFI::Constants qw(ZMQ_REP);

# Socket to talk to clients
my $context = ZMQ::FFI->new();
my $responder = $context->socket(ZMQ_REP);
$responder->bind("tcp://*:5555");

while (1) {
    $responder->recv();
    say "Received Hello";
    sleep 1;
    $responder->send("World");
}

<?php
/*
 *  Hello World server
 *  Binds REP socket to tcp://*:5555
 *  Expects "Hello" from client, replies with "World"
 * @author Ian Barber <ian(dot)barber(at)gmail(dot)com>
 */

$context = new ZMQContext(1);

//  Socket to talk to clients
$responder = new ZMQSocket($context, ZMQ::SOCKET_REP);
$responder->bind("tcp://*:5555");

while (true) {
    //  Wait for next request from client
    $request = $responder->recv();
    printf ("Received request: [%s]\n", $request);

    //  Do some 'work'
    sleep (1);

    //  Send reply back to client
    $responder->send("World");
}

#
#   Hello World server in Python
#   Binds REP socket to tcp://*:5555
#   Expects b"Hello" from client, replies with b"World"
#

import time
import zmq

context = zmq.Context()
socket = context.socket(zmq.REP)
socket.bind("tcp://*:5555")

while True:
    #  Wait for next request from client
    message = socket.recv()
    print(f"Received request: {message}")

    #  Do some 'work'
    time.sleep(1)

    #  Send reply back to client
    socket.send_string("World")

#lang racket
#|
   Hello World server in Racket
   Binds REP socket to tcp://*:5555
   Expects "Hello" from client, replies with "World"
|#
(require net/zmq)

(define ctxt (context 1))
(define sock (socket ctxt 'REP))
(socket-bind! sock "tcp://*:5555")

(let loop ()
  (define message (socket-recv! sock))
  (printf "Received request: ~a\n" message)
  (sleep 1)
  (socket-send! sock #"World")
  (loop))

(context-close! ctxt)

#!/usr/bin/env ruby

# author: Bill Desmarais bill@witsaid.com
# this code is licenced under the MIT/X11 licence.

require 'rubygems'
require 'ffi-rzmq'

context = ZMQ::Context.new(1)

puts "Starting Hello World server..."

# socket to listen for clients
socket = context.socket(ZMQ::REP)
socket.bind("tcp://*:5555")

while true do
  # Wait for next request from client
  request = ''
  rc = socket.recv_string(request)

  puts "Received request. Data: #{request.inspect}"

  # Do some 'work'
  sleep 1

  # Send reply back to client
  socket.send_string("world")

end

use std::{thread, time};

fn main() {
    let context = zmq::Context::new();
    let responder = context.socket(zmq::REP).unwrap();
    assert!(responder.bind("tcp://*:5555").is_ok());

    loop {
        let buffer = &mut [0; 10];
        responder.recv_into(buffer, 0).unwrap();
        println!("Received Hello");
        thread::sleep(time::Duration::from_secs(1));
        responder.send("World", 0).unwrap();
    }
}

//
//  Hello World server in Scala
//  Binds REP socket to tcp://*:5555
//  Expects "Hello" from client, replies with "World"
//
//  author Giovanni Ruggiero
//  email giovanni.ruggiero@gmail.com
//
//

import org.zeromq.ZMQ
import org.zeromq.ZMQ.{Context,Socket}

object HelloWorldServer {
  def main(args : Array[String]) {
    //  Prepare our context and socket
    val context = ZMQ.context(1)
    val socket = context.socket(ZMQ.REP)
		println ("starting")
    socket.bind ("tcp://*:5555")

    while (true) {
      //  Wait for next request from client
      //  We will wait for a 0-terminated string (C string) from the client,
      //  so that this server also works with The Guide's C and C++ "Hello World" clients
      val request = socket.recv (0)
      //  In order to display the 0-terminated string as a String,
      //  we omit the last byte from request
      println ("Received request: ["
							 + new String(request,0,request.length-1)  //  Creates a String from request, minus the last byte
							 + "]")

      //  Do some 'work'
      try {
        Thread.sleep (1000)
      } catch  {
        case e: InterruptedException => e.printStackTrace()
      }

      //  Send reply back to client
      //  We will send a 0-terminated string (C string) back to the client,
      //  so that this server also works with The Guide's C and C++ "Hello World" clients
      val reply = "World ".getBytes
      reply(reply.length-1)=0 //Sets the last byte of the reply to 0
      socket.send(reply, 0)
    }
  }
}

package require zmq

zmq context context
zmq socket responder context REP
responder bind "tcp://*:5555"

while {1} {
    zmq message request
    responder recv_msg request
    puts "Received [request data]"
    request close

    zmq message reply -data "World @ [clock format [clock seconds]]"
    responder send_msg reply
    reply close
}
responder close
context term

(** Hello World server *)

open Zmq
open Helpers

let () =
  with_context @@ fun ctx ->
  with_socket ctx Socket.rep @@ fun resp ->
  Socket.bind resp "tcp://*:5555";
  while not !should_exit do
    let s = Socket.recv resp in
    printfn "Received : %S" s;
    sleep_ms 1000; (* Do some 'work' *)
    Socket.send resp "World";
  done

//  Hello World server

#include <zmq.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>

int main (void)
{
    //  Socket to talk to clients
    void *context = zmq_ctx_new ();
    void *responder = zmq_socket (context, ZMQ_REP);
    int rc = zmq_bind (responder, "tcp://*:5555");
    assert (rc == 0);

    while (1) {
        char buffer [10];
        zmq_recv (responder, buffer, 10, 0);
        printf ("Received Hello\n");
        sleep (1);          //  Do some 'work'
        zmq_send (responder, "World", 5, 0);
    }
    return 0;
}

//
//  Hello World server in C++
//  Binds REP socket to tcp://*:5555
//  Expects "Hello" from client, replies with "World"
//
#include <zmq.hpp>
#include <string>
#include <iostream>
#ifndef _WIN32
#include <unistd.h>
#else
#include <windows.h>

#define sleep(n)	Sleep(n)
#endif

int main () {
    //  Prepare our context and socket
    zmq::context_t context (2);
    zmq::socket_t socket (context, zmq::socket_type::rep);
    socket.bind ("tcp://*:5555");

    while (true) {
        zmq::message_t request;

        //  Wait for next request from client
        socket.recv (request, zmq::recv_flags::none);
        std::cout << "Received Hello" << std::endl;

        //  Do some 'work'
        sleep(1);

        //  Send reply back to client
        zmq::message_t reply (5);
        memcpy (reply.data (), "World", 5);
        socket.send (reply, zmq::send_flags::none);
    }
    return 0;
}

;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
;;;
;;;  Hello World server in Common Lisp
;;;  Binds REP socket to tcp://*:5555
;;;  Expects "Hello" from client, replies with "World"
;;;
;;; Kamil Shakirov <kamils80@gmail.com>
;;;

(defpackage #:zguide.hwserver
  (:nicknames #:hwserver)
  (:use #:cl #:zhelpers)
  (:export #:main))

(in-package :zguide.hwserver)

(defun main ()
  ;; Prepare our context and socket
  (zmq:with-context (context 1)
    (zmq:with-socket (socket context zmq:rep)
      (zmq:bind socket "tcp://*:5555")

      (loop
        (let ((request (make-instance 'zmq:msg)))
          ;; Wait for next request from client
          (zmq:recv socket request)
          (message "Received request: [~A]~%"
                   (zmq:msg-data-as-string request))

          ;; Do some 'work'
          (sleep 1)

          ;; Send reply back to client
          (let ((reply (make-instance 'zmq:msg :data "World")))
            (zmq:send socket reply))))))

  (cleanup))

#! /usr/bin/env escript

%% Starts a local hello server.
%% Binds to tcp://localhost:5555

main(_Args) ->
    application:start(chumak),
    {ok, Socket} = chumak:socket(rep, "my-rep"),
    {ok, _Pid} = chumak:bind(Socket, tcp, "localhost", 5555),
    loop(Socket).

loop(Socket) ->
    {ok, RecvMessage} = chumak:recv(Socket),
    io:format("Received request : ~p\n", [RecvMessage]),

    timer:sleep(1000),

    chumak:send(Socket, "World"),
    loop(Socket).

defmodule Hwserver do
  @moduledoc """
  Generated by erl2ex (http://github.com/dazuma/erl2ex)
  From Erlang source: (Unknown source file)
  At: 2019-12-20 13:57:24

  """

  def main(_) do
    IO.puts("hwserver starting")
    {:ok, context} = :erlzmq.context()
    {:ok, responder} = :erlzmq.socket(context, :rep)
    :ok = :erlzmq.bind(responder, 'tcp://*:5555')
    loop(responder)
    :ok = :erlzmq.close(responder)
    :ok = :erlzmq.term(context)
  end


  def loop(responder) do
    {:ok, msg} = :erlzmq.recv(responder)
    :io.format('Received ~s~n', [msg])
    :timer.sleep(1000)
    :ok = :erlzmq.send(responder, "World")
    loop(responder)
  end

end

Hwserver.main(:ok)

//
// Hello World Zeromq server
//
// Author: Aaron Raddon   github.com/araddon
// Requires: http://github.com/alecthomas/gozmq
//
package main

import (
	"fmt"
	zmq "github.com/alecthomas/gozmq"
	"time"
)

func main() {
	context, _ := zmq.NewContext()
	socket, _ := context.NewSocket(zmq.REP)
	defer context.Close()
	defer socket.Close()
	socket.Bind("tcp://*:5555")

	// Wait for messages
	for {
		msg, _ := socket.Recv(0)
		println("Received ", string(msg))

		// do some fake "work"
		time.Sleep(time.Second)

		// send reply back to client
		reply := fmt.Sprintf("World")
		socket.Send([]byte(reply), 0)
	}
}

{-# LANGUAGE OverloadedStrings #-}

-- Hello World server

module Main where

import Control.Concurrent
import Control.Monad
import System.ZMQ4.Monadic

main :: IO ()
main = runZMQ $ do
    -- Socket to talk to clients
    responder <- socket Rep
    bind responder "tcp://*:5555"

    forever $ do
        buffer <- receive responder
        liftIO $ do
            putStrLn "Received Hello"
            threadDelay 1000000 -- Do some 'work'
        send responder [] "World"

package ;
import haxe.io.Bytes;
import neko.Lib;
import neko.Sys;
import org.zeromq.ZMQ;
import org.zeromq.ZMQContext;
import org.zeromq.ZMQException;
import org.zeromq.ZMQSocket;

/**
 * Hello World server in Haxe
 * Binds REP to tcp://*:5556
 * Expects "Hello" from client, replies with "World"
 * Use with HelloWorldClient.hx
 * 
 */
class HelloWorldServer 
{

	public static function main() {
		
		var context:ZMQContext = ZMQContext.instance();
		var responder:ZMQSocket = context.socket(ZMQ_REP);

		Lib.println("** HelloWorldServer (see: https://zguide.zeromq.cn/page:all#Ask-and-Ye-Shall-Receive)");

		responder.setsockopt(ZMQ_LINGER, 0);
		responder.bind("tcp://*:5556");
		
		try {
			while (true) {
				// Wait for next request from client
				var request:Bytes = responder.recvMsg();
				
				trace ("Received request:" + request.toString());
				
				// Do some work
				Sys.sleep(1);
				
				// Send reply back to client
				responder.sendMsg(Bytes.ofString("World"));
			}
		} catch (e:ZMQException) {
			trace (e.toString());
		}
		responder.close();
		context.term();
		
	}
	
}

package guide;

//
//  Hello World server in Java
//  Binds REP socket to tcp://*:5555
//  Expects "Hello" from client, replies with "World"
//

import org.zeromq.SocketType;
import org.zeromq.ZMQ;
import org.zeromq.ZContext;

public class hwserver
{
    public static void main(String[] args) throws Exception
    {
        try (ZContext context = new ZContext()) {
            // Socket to talk to clients
            ZMQ.Socket socket = context.createSocket(SocketType.REP);
            socket.bind("tcp://*:5555");

            while (!Thread.currentThread().isInterrupted()) {
                byte[] reply = socket.recv(0);
                System.out.println(
                    "Received " + ": [" + new String(reply, ZMQ.CHARSET) + "]"
                );

                Thread.sleep(1000); //  Do some 'work'

                String response = "world";
                socket.send(response.getBytes(ZMQ.CHARSET), 0);
            }
        }
    }
}

#!/usr/bin/env julia

#
# Hello World server in Julia
# Binds REP socket to tcp://*:5555
# Expects "Hello" from client, replies "World"
#

using ZMQ

context = Context()
socket = Socket(context, REP)
ZMQ.bind(socket, "tcp://*:5555")

while true
    # Wait for next request from client
    message = String(ZMQ.recv(socket))
    println("Received request: $message")

    # Do some 'work'
    sleep(1)

    # Send reply back to client
    ZMQ.send(socket, "World")
end

# classy hit men always clean up when finish the job.
ZMQ.close(socket)
ZMQ.close(context)

--
--  Hello World server
--  Binds REP socket to tcp://*:5555
--  Expects "Hello" from client, replies with "World"
--
--  Author: Robert G. Jakabosky <bobby@sharedrealm.com>
--
require"zmq"
require"zhelpers"

local context = zmq.init(1)

--  Socket to talk to clients
local socket = context:socket(zmq.REP)
socket:bind("tcp://*:5555")

while true do
    --  Wait for next request from client
    local request = socket:recv()
    print("Received Hello [" .. request .. "]")

    --  Do some 'work'
		s_sleep(1000)

    --  Send reply back to client
    socket:send("World")
end
--  We never get here but if we did, this would be how we end
socket:close()
context:term()

// Hello World server
// Binds REP socket to tcp://*:5555
// Expects "Hello" from client, replies with "world"

var zmq = require('zeromq');

// socket to talk to clients
var responder = zmq.socket('rep');

responder.on('message', function(request) {
  console.log("Received request: [", request.toString(), "]");

  // do some 'work'
  setTimeout(function() {

    // send reply back to client.
    responder.send("World");
  }, 1000);
});

responder.bind('tcp://*:5555', function(err) {
  if (err) {
    console.log(err);
  } else {
    console.log("Listening on 5555...");
  }
});

process.on('SIGINT', function() {
  responder.close();
});

//
//  Hello World server
//  Binds REP socket to tcp://*:5555
//  Expects "Hello" from client, replies with "World"
//
#import <Foundation/Foundation.h>
#import "ZMQObjc.h"

int
main(void)
{
	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
	ZMQContext *ctx = [[[ZMQContext alloc] initWithIOThreads:1U] autorelease];

	/* Get a socket to talk to clients. */
	static NSString *const kEndpoint = @"tcp://*:5555";
	ZMQSocket *responder = [ctx socketWithType:ZMQ_REP];
	BOOL didBind = [responder bindToEndpoint:kEndpoint];
	if (!didBind) {
		NSLog(@"*** Failed to bind to endpoint [%@].", kEndpoint);
		return EXIT_FAILURE;
	}

	for (;;) {
		/* Create a local pool so that autoreleased objects can be disposed of
		 * at the end of each go through the loop.
		 * Otherwise, memory usage would continue to rise
		 * until the end of the process.
		 */
		NSAutoreleasePool *localPool = [[NSAutoreleasePool alloc] init];

		/* Block waiting for next request from client. */
		NSData *request = [responder receiveDataWithFlags:0];
		NSString *text = [[[NSString alloc]
				initWithData:request encoding:NSUTF8StringEncoding] autorelease];
		NSLog(@"Received request: %@", text);

		/* "Work" for a bit. */
		sleep(1);

		/* Send reply back to client. */
		static NSString *const kWorld = @"World";
		const char *replyCString = [kWorld UTF8String];
		const NSUInteger replyLength = [kWorld
				lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
		NSData *reply = [NSData dataWithBytes:replyCString length:replyLength];
		[responder sendData:reply withFlags:0];

		[localPool drain];
	}

	/* Close the socket to avoid blocking in -[ZMQContext terminate]. */
	[responder close];
	/* Dispose of the context and socket. */
	[pool drain];
	return EXIT_SUCCESS;
}

# Hello World server in Perl

use strict;
use warnings;
use v5.10;

use ZMQ::FFI;
use ZMQ::FFI::Constants qw(ZMQ_REP);

# Socket to talk to clients
my $context = ZMQ::FFI->new();
my $responder = $context->socket(ZMQ_REP);
$responder->bind("tcp://*:5555");

while (1) {
    $responder->recv();
    say "Received Hello";
    sleep 1;
    $responder->send("World");
}

<?php
/*
 *  Hello World server
 *  Binds REP socket to tcp://*:5555
 *  Expects "Hello" from client, replies with "World"
 * @author Ian Barber <ian(dot)barber(at)gmail(dot)com>
 */

$context = new ZMQContext(1);

//  Socket to talk to clients
$responder = new ZMQSocket($context, ZMQ::SOCKET_REP);
$responder->bind("tcp://*:5555");

while (true) {
    //  Wait for next request from client
    $request = $responder->recv();
    printf ("Received request: [%s]\n", $request);

    //  Do some 'work'
    sleep (1);

    //  Send reply back to client
    $responder->send("World");
}

#
#   Hello World server in Python
#   Binds REP socket to tcp://*:5555
#   Expects b"Hello" from client, replies with b"World"
#

import time
import zmq

context = zmq.Context()
socket = context.socket(zmq.REP)
socket.bind("tcp://*:5555")

while True:
    #  Wait for next request from client
    message = socket.recv()
    print(f"Received request: {message}")

    #  Do some 'work'
    time.sleep(1)

    #  Send reply back to client
    socket.send_string("World")

#lang racket
#|
   Hello World server in Racket
   Binds REP socket to tcp://*:5555
   Expects "Hello" from client, replies with "World"
|#
(require net/zmq)

(define ctxt (context 1))
(define sock (socket ctxt 'REP))
(socket-bind! sock "tcp://*:5555")

(let loop ()
  (define message (socket-recv! sock))
  (printf "Received request: ~a\n" message)
  (sleep 1)
  (socket-send! sock #"World")
  (loop))

(context-close! ctxt)

#!/usr/bin/env ruby

# author: Bill Desmarais bill@witsaid.com
# this code is licenced under the MIT/X11 licence.

require 'rubygems'
require 'ffi-rzmq'

context = ZMQ::Context.new(1)

puts "Starting Hello World server..."

# socket to listen for clients
socket = context.socket(ZMQ::REP)
socket.bind("tcp://*:5555")

while true do
  # Wait for next request from client
  request = ''
  rc = socket.recv_string(request)

  puts "Received request. Data: #{request.inspect}"

  # Do some 'work'
  sleep 1

  # Send reply back to client
  socket.send_string("world")

end

use std::{thread, time};

fn main() {
    let context = zmq::Context::new();
    let responder = context.socket(zmq::REP).unwrap();
    assert!(responder.bind("tcp://*:5555").is_ok());

    loop {
        let buffer = &mut [0; 10];
        responder.recv_into(buffer, 0).unwrap();
        println!("Received Hello");
        thread::sleep(time::Duration::from_secs(1));
        responder.send("World", 0).unwrap();
    }
}

//
//  Hello World server in Scala
//  Binds REP socket to tcp://*:5555
//  Expects "Hello" from client, replies with "World"
//
//  author Giovanni Ruggiero
//  email giovanni.ruggiero@gmail.com
//
//

import org.zeromq.ZMQ
import org.zeromq.ZMQ.{Context,Socket}

object HelloWorldServer {
  def main(args : Array[String]) {
    //  Prepare our context and socket
    val context = ZMQ.context(1)
    val socket = context.socket(ZMQ.REP)
		println ("starting")
    socket.bind ("tcp://*:5555")

    while (true) {
      //  Wait for next request from client
      //  We will wait for a 0-terminated string (C string) from the client,
      //  so that this server also works with The Guide's C and C++ "Hello World" clients
      val request = socket.recv (0)
      //  In order to display the 0-terminated string as a String,
      //  we omit the last byte from request
      println ("Received request: ["
							 + new String(request,0,request.length-1)  //  Creates a String from request, minus the last byte
							 + "]")

      //  Do some 'work'
      try {
        Thread.sleep (1000)
      } catch  {
        case e: InterruptedException => e.printStackTrace()
      }

      //  Send reply back to client
      //  We will send a 0-terminated string (C string) back to the client,
      //  so that this server also works with The Guide's C and C++ "Hello World" clients
      val reply = "World ".getBytes
      reply(reply.length-1)=0 //Sets the last byte of the reply to 0
      socket.send(reply, 0)
    }
  }
}

package require zmq

zmq context context
zmq socket responder context REP
responder bind "tcp://*:5555"

while {1} {
    zmq message request
    responder recv_msg request
    puts "Received [request data]"
    request close

    zmq message reply -data "World @ [clock format [clock seconds]]"
    responder send_msg reply
    reply close
}
responder close
context term

(** Hello World server *)

open Zmq
open Helpers

let () =
  with_context @@ fun ctx ->
  with_socket ctx Socket.rep @@ fun resp ->
  Socket.bind resp "tcp://*:5555";
  while not !should_exit do
    let s = Socket.recv resp in
    printfn "Received : %S" s;
    sleep_ms 1000; (* Do some 'work' *)
    Socket.send resp "World";
  done

//  Hello World client
#include <zmq.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>

int main (void)
{
    printf ("Connecting to hello world server...\n");
    void *context = zmq_ctx_new ();
    void *requester = zmq_socket (context, ZMQ_REQ);
    zmq_connect (requester, "tcp://localhost:5555");

    int request_nbr;
    for (request_nbr = 0; request_nbr != 10; request_nbr++) {
        char buffer [10];
        printf ("Sending Hello %d...\n", request_nbr);
        zmq_send (requester, "Hello", 5, 0);
        zmq_recv (requester, buffer, 10, 0);
        printf ("Received World %d\n", request_nbr);
    }
    zmq_close (requester);
    zmq_ctx_destroy (context);
    return 0;
}

//
//  Hello World client in C++
//  Connects REQ socket to tcp://localhost:5555
//  Sends "Hello" to server, expects "World" back
//
#include <zmq.hpp>
#include <string>
#include <iostream>

int main ()
{
    //  Prepare our context and socket
    zmq::context_t context (1);
    zmq::socket_t socket (context, zmq::socket_type::req);

    std::cout << "Connecting to hello world server..." << std::endl;
    socket.connect ("tcp://localhost:5555");

    //  Do 10 requests, waiting each time for a response
    for (int request_nbr = 0; request_nbr != 10; request_nbr++) {
        zmq::message_t request (5);
        memcpy (request.data (), "Hello", 5);
        std::cout << "Sending Hello " << request_nbr << "..." << std::endl;
        socket.send (request, zmq::send_flags::none);

        //  Get the reply.
        zmq::message_t reply;
        socket.recv (reply, zmq::recv_flags::none);
        std::cout << "Received World " << request_nbr << std::endl;
    }
    return 0;
}

;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
;;;
;;;  Hello World client in Common Lisp
;;;  Connects REQ socket to tcp://localhost:5555
;;;  Sends "Hello" to server, expects "World" back
;;;
;;; Kamil Shakirov <kamils80@gmail.com>
;;;

(defpackage #:zguide.hwclient
  (:nicknames #:hwclient)
  (:use #:cl #:zhelpers)
  (:export #:main))

(in-package :zguide.hwclient)

(defun main ()
  ;; Prepare our context and socket
  (zmq:with-context (context 1)
    (zmq:with-socket (socket context zmq:req)
      (message "Connecting to hello world server...~%")
      (zmq:connect socket "tcp://localhost:5555")

      ;; Do 10 requests, waiting each time for a response
      (dotimes (request-nbr 10)
        (let ((request (make-instance 'zmq:msg :data "Hello")))
          (message "Sending request ~D...~%" request-nbr)
          (zmq:send socket request))

        ;; Get the reply
        (let ((response (make-instance 'zmq:msg)))
          (zmq:recv socket response)
          (message "Received reply ~D: [~A]~%"
                   request-nbr (zmq:msg-data-as-string response))))))

  (cleanup))

#! /usr/bin/env escript

%%
%% "Hello world" client example.
%% Connects to tcp://localhost:5555
%% Sends <<"Hello">> to server and prints the response
%%

main(_Args) ->
    application:start(chumak),
    {ok, Socket} = chumak:socket(req, "my-req"),
    {ok, _Pid} = chumak:connect(Socket, tcp, "localhost", 5555),
    loop(Socket).


loop(Socket) ->
    chumak:send(Socket, "Hello"),
    {ok, RecvMessage} = chumak:recv(Socket),
    io:format("Recv Reply: ~p\n", [RecvMessage]),
    loop(Socket).

defmodule Hwclient do
  @moduledoc """
  Generated by erl2ex (http://github.com/dazuma/erl2ex)
  From Erlang source: (Unknown source file)
  At: 2019-12-20 13:57:23

  """

  def main(_) do
    {:ok, context} = :erlzmq.context()
    :io.format('Connecting to hello world server...~n')
    {:ok, requester} = :erlzmq.socket(context, :req)
    :ok = :erlzmq.connect(requester, 'tcp://localhost:5555')
    :lists.foreach(fn n ->
      :io.format('Sending Hello ~b...~n', [n])
      :ok = :erlzmq.send(requester, "Hello")
      {:ok, reply} = :erlzmq.recv(requester)
      :io.format('Received ~s ~b~n', [reply, n])
    end, :lists.seq(1, 10))
    :ok = :erlzmq.close(requester)
    :ok = :erlzmq.term(context)
  end

end

Hwclient.main(:ok)

//
// Hello World Zeromq Client
//
// Author: Aaron Raddon   github.com/araddon
// Requires: http://github.com/alecthomas/gozmq
//
package main

import (
	"fmt"
	zmq "github.com/alecthomas/gozmq"
)

func main() {
	context, _ := zmq.NewContext()
	socket, _ := context.NewSocket(zmq.REQ)
	defer context.Close()
	defer socket.Close()

	fmt.Printf("Connecting to hello world server...")
	socket.Connect("tcp://localhost:5555")

	for i := 0; i < 10; i++ {
		// send hello
		msg := fmt.Sprintf("Hello %d", i)
		socket.Send([]byte(msg), 0)
		println("Sending ", msg)

		// Wait for reply:
		reply, _ := socket.Recv(0)
		println("Received ", string(reply))
	}
}

{-# LANGUAGE OverloadedStrings #-}

-- Hello World client

module Main where

import Control.Monad
import System.ZMQ4.Monadic

main :: IO ()
main = runZMQ $ do
    liftIO $ putStrLn "Connecting to hello world server..."

    requester <- socket Req
    connect requester "tcp://localhost:5555"

    forM_ [1..10] $ \i -> do
        liftIO . putStrLn $ "Sending Hello " ++ show i ++ "..."
        send requester [] "Hello"
        _ <- receive requester
        liftIO . putStrLn $ "Received World " ++ show i

package ;
import haxe.io.Bytes;
import neko.Lib;
import neko.Sys;

import org.zeromq.ZMQ;
import org.zeromq.ZMQContext;
import org.zeromq.ZMQSocket;

/**
 * Hello World client in Haxe.
 * Use with HelloWorldServer.hx and MTServer.hx
 */
class HelloWorldClient 
{
	
	public static function main() {
		var context:ZMQContext = ZMQContext.instance();
		var socket:ZMQSocket = context.socket(ZMQ_REQ);
		
		Lib.println("** HelloWorldClient (see: https://zguide.zeromq.cn/page:all#Ask-and-Ye-Shall-Receive)");
		
		trace ("Connecting to hello world server...");
		socket.connect ("tcp://localhost:5556");
		
		// Do 10 requests, waiting each time for a response
		for (i in 0...10) {
			var requestString = "Hello ";
			
			// Send the message
			trace ("Sending request " + i + " ...");
			socket.sendMsg(Bytes.ofString(requestString));
			
			// Wait for the reply
			var msg:Bytes = socket.recvMsg();
			
			trace ("Received reply " + i + ": [" + msg.toString() + "]");
		}
		
		// Shut down socket and context
		socket.close();
		context.term();
	}
}

package guide;

//
//  Hello World client in Java
//  Connects REQ socket to tcp://localhost:5555
//  Sends "Hello" to server, expects "World" back
//

import org.zeromq.SocketType;
import org.zeromq.ZMQ;
import org.zeromq.ZContext;

public class hwclient
{
    public static void main(String[] args)
    {
        try (ZContext context = new ZContext()) {
            //  Socket to talk to server
            System.out.println("Connecting to hello world server");

            ZMQ.Socket socket = context.createSocket(SocketType.REQ);
            socket.connect("tcp://localhost:5555");

            for (int requestNbr = 0; requestNbr != 10; requestNbr++) {
                String request = "Hello";
                System.out.println("Sending Hello " + requestNbr);
                socket.send(request.getBytes(ZMQ.CHARSET), 0);

                byte[] reply = socket.recv(0);
                System.out.println(
                    "Received " + new String(reply, ZMQ.CHARSET) + " " +
                    requestNbr
                );
            }
        }
    }
}

#!/usr/bin/env julia

#
# Hello World client in Julia
# Connects REQ socket to tcp://localhost:5555
# Sends "Hello" to server, expects "World" back
#

using ZMQ

context = Context()

# Socket to talk to server
println("Connecting to hello world server...")
socket = Socket(context, REQ)
ZMQ.connect(socket, "tcp://localhost:5555")

for request in 1:10
    println("Sending request $request ...")
    ZMQ.send(socket, "Hello")

    # Get the reply.
    message = String(ZMQ.recv(socket))
    println("Received reply $request [ $message ]")
end

# Making a clean exit.
ZMQ.close(socket)
ZMQ.close(context)

--
--  Hello World client
--  Connects REQ socket to tcp://localhost:5555
--  Sends "Hello" to server, expects "World" back
--
--  Author: Robert G. Jakabosky <bobby@sharedrealm.com>
--
require"zmq"

local context = zmq.init(1)

--  Socket to talk to server
print("Connecting to hello world server...")
local socket = context:socket(zmq.REQ)
socket:connect("tcp://localhost:5555")

for n=1,10 do
    print("Sending Hello " .. n .. " ...")
    socket:send("Hello")

    local reply = socket:recv()
    print("Received World " ..  n .. " [" .. reply .. "]")
end
socket:close()
context:term()

// Hello World client
// Connects REQ socket to tcp://localhost:5555
// Sends "Hello" to server.

var zmq = require('zeromq');

// socket to talk to server
console.log("Connecting to hello world server...");
var requester = zmq.socket('req');

var x = 0;
requester.on("message", function(reply) {
  console.log("Received reply", x, ": [", reply.toString(), ']');
  x += 1;
  if (x === 10) {
    requester.close();
    process.exit(0);
  }
});

requester.connect("tcp://localhost:5555");

for (var i = 0; i < 10; i++) {
  console.log("Sending request", i, '...');
  requester.send("Hello");
}

process.on('SIGINT', function() {
  requester.close();
});

//
//  Hello World client
//  Connects REQ socket to tcp://localhost:5555
//  Sends "Hello" to server, expects "World" back
//
#import "ZMQObjC.h"

int
main (void)
{
	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
	ZMQContext *ctx = [[[ZMQContext alloc] initWithIOThreads:1U] autorelease];
	
	/* Get a socket to talk to clients. */
	NSLog(@"Connecting to hello world server...");
	static NSString *const kEndpoint = @"tcp://localhost:5555";
	ZMQSocket *requester = [ctx socketWithType:ZMQ_REQ];
	BOOL didBind = [requester connectToEndpoint:kEndpoint];
	if (!didBind) {
		NSLog(@"*** Failed to bind to endpoint [%@].", kEndpoint);
		return EXIT_FAILURE;
	}

	static const int kMaxRequest = 10;
	NSData *const request = [@"Hello" dataUsingEncoding:NSUTF8StringEncoding];
	for (int request_nbr = 0; request_nbr < kMaxRequest; ++request_nbr) {
		NSAutoreleasePool *localPool = [[NSAutoreleasePool alloc] init];

		NSLog(@"Sending request %d.", request_nbr);
		[requester sendData:request withFlags:0];
		NSData *reply = [requester receiveDataWithFlags:0];
		NSString *text = [[[NSString alloc]
				initWithData:reply encoding:NSUTF8StringEncoding] autorelease];
		NSLog(@"Received reply %d: %@", request_nbr, text);

		[localPool drain];
	}

	[requester close];
	[pool drain];
	return EXIT_SUCCESS;
}

# Hello World client in Perl

use strict;
use warnings;
use v5.10;

use ZMQ::FFI;
use ZMQ::FFI::Constants qw(ZMQ_REQ);

say "Connecting to hello world server...";
my $context = ZMQ::FFI->new();
my $requestor = $context->socket(ZMQ_REQ);
$requestor->connect("tcp://localhost:5555");

for my $request_nbr (0..9) {
    say "Sending Hello $request_nbr...";
    $requestor->send("Hello");
    $requestor->recv();
    say "Received World $request_nbr";
}

<?php
/*
 *  Hello World client
 *  Connects REQ socket to tcp://localhost:5555
 *  Sends "Hello" to server, expects "World" back
 * @author Ian Barber <ian(dot)barber(at)gmail(dot)com>
 */

$context = new ZMQContext();

//  Socket to talk to server
echo "Connecting to hello world server...\n";
$requester = new ZMQSocket($context, ZMQ::SOCKET_REQ);
$requester->connect("tcp://localhost:5555");

for ($request_nbr = 0; $request_nbr != 10; $request_nbr++) {
    printf ("Sending request %d...\n", $request_nbr);
    $requester->send("Hello");

    $reply = $requester->recv();
    printf ("Received reply %d: [%s]\n", $request_nbr, $reply);
}

#
#   Hello World client in Python
#   Connects REQ socket to tcp://localhost:5555
#   Sends "Hello" to server, expects "World" back
#

import zmq

context = zmq.Context()

#  Socket to talk to server
print("Connecting to hello world server...")
socket = context.socket(zmq.REQ)
socket.connect("tcp://localhost:5555")

#  Do 10 requests, waiting each time for a response
for request in range(10):
    print(f"Sending request {request} ...")
    socket.send_string("Hello")

    #  Get the reply.
    message = socket.recv()
    print(f"Received reply {request} [ {message} ]")

#lang racket
#|
#   Hello World client in Racket
#   Connects REQ socket to tcp://localhost:5555
#   Sends "Hello" to server, expects "World" back
|#
(require net/zmq)

;  Prepare our context and sockets
(define ctxt (context 1))
(define sock (socket ctxt 'REQ))

(printf "Connecting to hello world server...\n")
(socket-connect! sock "tcp://localhost:5555")

;  Do 10 requests, waiting each time for a response
(for ([request (in-range 10)])
  (printf "Sending request ~a...\n" request)
  (socket-send! sock #"Hello")
  
  ;  Get the reply.
  (define message (socket-recv! sock))
  (printf "Received reply ~a [~a]\n" request message))

(context-close! ctxt)

#!/usr/bin/env ruby

require 'rubygems'
require 'ffi-rzmq'

context = ZMQ::Context.new(1)

# Socket to talk to server
puts "Connecting to hello world server..."
requester = context.socket(ZMQ::REQ)
requester.connect("tcp://localhost:5555")

0.upto(9) do |request_nbr|
  puts "Sending request #{request_nbr}..."
  requester.send_string "Hello"

  reply = ''
  rc = requester.recv_string(reply)
  
  puts "Received reply #{request_nbr}: [#{reply}]"
end

fn main() {
    println!("Connecting to hello world server...");
    let context = zmq::Context::new();
    let requester = context.socket(zmq::REQ).unwrap();
    assert!(requester.connect("tcp://localhost:5555").is_ok());

    for request_nbr in 0..10 {
        let buffer = &mut [0; 10];
        println!("Sending Hello {:?}...", request_nbr);
        requester.send("Hello", 0).unwrap();
        requester.recv_into(buffer, 0).unwrap();
        println!("Received World {:?}", request_nbr);
    }
}

/*
 *
 *  Hello World client in Scala
 *  Connects REQ socket to tcp://localhost:5555
 *  Sends "Hello" to server, expects "World" back
 *
 *  @author Giovanni Ruggiero
 *  @email giovanni.ruggiero@gmail.com
*/

import org.zeromq.ZMQ
import org.zeromq.ZMQ.{Context,Socket}

object HelloWorldClient{
  def main(args : Array[String]) {
    //  Prepare our context and socket
    val context = ZMQ.context(1)
    val socket = context.socket(ZMQ.REQ)

    println("Connecting to hello world server...")
    socket.connect ("tcp://localhost:5555")

    //  Do 10 requests, waiting each time for a response
		for (request_nbr <- 1 to 10)  {
      //  Create a "Hello" message.
      //  Ensure that the last byte of our "Hello" message is 0 because
      //  our "Hello World" server is expecting a 0-terminated string:
			val request = "Hello ".getBytes()
      request(request.length-1)=0 //Sets the last byte to 0
      // Send the message
      println("Sending request " + request_nbr + "...") + request.toString
      socket.send(request, 0)

      //  Get the reply.
      val reply = socket.recv(0)
      //  When displaying reply as a String, omit the last byte because
      //  our "Hello World" server has sent us a 0-terminated string:
      println("Received reply " + request_nbr + ": [" + new String(reply,0,reply.length-1) + "]")
    }
  }
}

package require zmq

zmq context context
zmq socket client context REQ
client connect "tcp://localhost:5555"

for {set i 0} {$i < 10} {incr i} {
    zmq message msg -data "Hello @ [clock format [clock seconds]]"
    client send_msg msg
    msg close

    zmq message msg
    client recv_msg msg
    puts  "Received [msg data]/[msg size]"
    msg close
}

client close
context term

(** Hello World client *)

open Zmq
open Helpers

let () =
  printfn "Connecting to hello world server...";
  with_context @@ fun ctx ->
  with_socket ctx Socket.req @@ fun req ->
  Socket.connect req "tcp://localhost:5555";
  for i = 0 to 9 do
    printfn "Sending Hello %d..." i;
    Socket.send req "Hello";
    let answer = Socket.recv req in
    printfn "Received %d : %S" i answer
  done

//  Report 0MQ version

#include <zmq.h>

int main (void)
{
    int major, minor, patch;
    zmq_version (&major, &minor, &patch);
    printf ("Current 0MQ version is %d.%d.%d\n", major, minor, patch);
    return 0;
}

//
//  Report 0MQ version
//
#include "zhelpers.hpp"

int main ()
{
    s_version ();
    return EXIT_SUCCESS;
}

;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
;;;
;;; Report 0MQ version
;;;
;;; Kamil Shakirov <kamils80@gmail.com>
;;;

(defpackage #:zguide.zversion
  (:nicknames #:zversion)
  (:use #:cl #:zhelpers)
  (:export #:main))

(in-package :zguide.zversion)

(defun main ()
  (version))

#! /usr/bin/env escript
%%
%% Report 0MQ version
%%

main(_) ->
    {Maj, Min, Patch} = erlzmq:version(),
    io:format("Current 0MQ version is ~b.~b.~b~n", [Maj, Min, Patch]).

defmodule Version do
  @moduledoc """
  Generated by erl2ex (http://github.com/dazuma/erl2ex)
  From Erlang source: (Unknown source file)
  At: 2019-12-20 13:57:38

  """

  def main() do
    {maj, var_min, patch} = :erlzmq.version()
    :io.format('Current 0MQ version is ~b.~b.~b~n', [maj, var_min, patch])
  end

end

Version.main

//
// 0MQ version example.
//
// Author: Max Riveiro <kavu13@gmail.com>
// Requires: http://github.com/alecthomas/gozmq
//
package main

import (
	"fmt"
	zmq "github.com/alecthomas/gozmq"
)

func main() {
	major, minor, patch := zmq.Version()
	fmt.Printf("Current 0MQ version is %d.%d.%d\n", major, minor, patch)
}

module Main where

import System.ZMQ4 (version)
import Text.Printf (printf)

main :: IO ()
main = do
    (major, minor, patch) <- version
    printf "Current 0MQ version is %d.%d.%d" major minor patch

package guide;

import org.zeromq.ZMQ;

//  Report 0MQ version
public class version
{
    public static void main(String[] args)
    {
        String version = ZMQ.getVersionString();
        int fullVersion = ZMQ.getFullVersion();

        System.out.println(
            String.format(
                "Version string: %s, Version int: %d", version, fullVersion
            )
        );
    }
}

#!/usr/bin/env julia

using ZMQ

println("Current ZMQ version is $(ZMQ.version)")

--
--  Report 0MQ version
--
--  Author: Robert G. Jakabosky <bobby@sharedrealm.com>
--
require"zmq"

print("Current 0MQ version is " .. table.concat(zmq.version(), '.'))

// Report 0MQ version in Node.js

var zmq = require('zeromq');

console.log("Current 0MQ version is " + zmq.version);

/* Reports the 0MQ version. */
#import "ZMQObjC.h"

int
main(void)
{
	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
	int major = 0;
	int minor = 0;
	int patch = 0;
	[ZMQContext getZMQVersionMajor:&major minor:&minor patch:&patch];
	NSLog(@"Current 0MQ version is %d.%d.%d.", major, minor, patch);
	[pool drain];
	return EXIT_SUCCESS;
}

# Report 0MQ version in Perl

use strict;
use warnings;
use v5.10;

use ZMQ::FFI;

my ($major, $minor, $patch) = ZMQ::FFI->new->version;
say "Current 0MQ version is $major.$minor.$patch";

<?php
/* Report 0MQ version
 *
 * @author Ian Barber <ian(dot)barber(at)gmail(dot)com>
 */

if (class_exists("ZMQ") && defined("ZMQ::LIBZMQ_VER")) {
    echo ZMQ::LIBZMQ_VER, PHP_EOL;
}

# Report 0MQ version
#
# Author: Lev Givon <lev(at)columbia(dot)edu>

import zmq

print(f"Current libzmq version is {zmq.zmq_version()}")
print(f"Current  pyzmq version is {zmq.__version__}")

#!/usr/bin/env ruby

#
#  Report 0MQ version
#

require 'rubygems'
require 'ffi-rzmq'

version = LibZMQ.version
puts "Current 0MQ version is %d.%d.%d\n" \
    % [version[:major], version[:minor], version[:patch]]

fn main() {
    let (major, minor, patch) = zmq::version();
    println!("Current 0MQ version is {}.{}.{}", major, minor, patch);
}

/*
 *
 * Version in Scala
 *
 * @author Vadim Shalts
 * @email vshalts@gmail.com
*/

import org.zeromq.ZMQ

object version {

  def main(args: Array[String]) {
    printf("Version string: %s, Version int: %d\n", ZMQ.getVersionString, ZMQ.getFullVersion)
  }
}

#
#  Report 0MQ version
#

package require zmq

puts [zmq version]

(* Report 0MQ version *)

open Helpers

let () =
  let (major, minor, patch) = Zmq.version () in
  printfn "Current 0MQ version is %d.%d.%d" major minor patch

//  Weather update server
//  Binds PUB socket to tcp://*:5556
//  Publishes random weather updates

#include "zhelpers.h"

int main (void)
{
    //  Prepare our context and publisher
    void *context = zmq_ctx_new ();
    void *publisher = zmq_socket (context, ZMQ_PUB);
    int rc = zmq_bind (publisher, "tcp://*:5556");
    assert (rc == 0);

    //  Initialize random number generator
    srandom ((unsigned) time (NULL));
    while (1) {
        //  Get values that will fool the boss
        int zipcode, temperature, relhumidity;
        zipcode     = randof (100000);
        temperature = randof (215) - 80;
        relhumidity = randof (50) + 10;

        //  Send message to all subscribers
        char update [20];
        sprintf (update, "%05d %d %d", zipcode, temperature, relhumidity);
        s_send (publisher, update);
    }
    zmq_close (publisher);
    zmq_ctx_destroy (context);
    return 0;
}

//
//  Weather update server in C++
//  Binds PUB socket to tcp://*:5556
//  Publishes random weather updates
//
#include <zmq.hpp>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#if (defined (WIN32))
#include <zhelpers.hpp>
#endif

#define within(num) (int) ((float) num * random () / (RAND_MAX + 1.0))

int main () {

    //  Prepare our context and publisher
    zmq::context_t context (1);
    zmq::socket_t publisher (context, zmq::socket_type::pub);
    publisher.bind("tcp://*:5556");
    publisher.bind("ipc://weather.ipc");				// Not usable on Windows.

    //  Initialize random number generator
    srandom ((unsigned) time (NULL));
    while (1) {

        int zipcode, temperature, relhumidity;

        //  Get values that will fool the boss
        zipcode     = within (100000);
        temperature = within (215) - 80;
        relhumidity = within (50) + 10;

        //  Send message to all subscribers
        zmq::message_t message(20);
        snprintf ((char *) message.data(), 20 ,
        	"%05d %d %d", zipcode, temperature, relhumidity);
        publisher.send(message, zmq::send_flags::none);

    }
    return 0;
}

;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
;;;
;;;  Weather update server in Common Lisp
;;;  Binds PUB socket to tcp://*:5556
;;;  Publishes random weather updates
;;;
;;; Kamil Shakirov <kamils80@gmail.com>
;;;

(defpackage #:zguide.wuserver
  (:nicknames #:wuserver)
  (:use #:cl #:zhelpers)
  (:export #:main))

(in-package :zguide.wuserver)

(defun main ()
  ;; Prepare our context and socket
  (zmq:with-context (context 1)
    (zmq:with-socket (publisher context zmq:pub)
      (zmq:bind publisher "tcp://*:5556")
      (zmq:bind publisher "ipc://weather.ipc")

      (loop
        ;; Get values that will fool the boss
        (let ((zipcode (within 100000))
              (temperature (- (within 215) 80))
              (relhumidity (+ (within 50) 10)))

          ;; Send message to all subscribers
          (let ((message
                 (make-instance 'zmq:msg
                                :data (format nil "~5,'0D ~D ~D"
                                              zipcode
                                              temperature
                                              relhumidity))))

            ;; Send message to all subscribers
            (zmq:send publisher message))))))

  (cleanup))

#! /usr/bin/env escript
%%
%% Weather update server
%% Binds PUB socket to tcp://*.5556
%% Publishes random weather updates
%%

main(_Args) ->
    application:start(chumak),
    {ok, Publisher} = chumak:socket(pub),

    case chumak:bind(Publisher, tcp, "localhost", 5556) of
        {ok, _BindPid} ->
            io:format("Binding OK with Pid: ~p\n", [Publisher]);
        {error, Reason} ->
            io:format("Connection Failed for this reason: ~p\n", [Reason]);
        X ->
            io:format("Unhandled reply for bind ~p \n", [X])
    end,
    loop(Publisher).


loop(Publisher) ->
    Zipcode = rand:uniform(100000),
    Temperature = rand:uniform(135),
    Relhumidity = rand:uniform(50) + 10,

    BinZipCode = erlang:integer_to_binary(Zipcode),
    BinTemperature = erlang:integer_to_binary(Temperature),
    BinRelhumidity = erlang:integer_to_binary(Relhumidity),
    ok = chumak:send(Publisher, [BinZipCode, " ", BinTemperature, " ", BinRelhumidity]),
    loop(Publisher).

defmodule Wuserver do
  @moduledoc """
  Generated by erl2ex (http://github.com/dazuma/erl2ex)
  From Erlang source: (Unknown source file)
  At: 2019-12-20 13:57:40

  """

  def main(_) do
    {:ok, context} = :erlzmq.context()
    {:ok, publisher} = :erlzmq.socket(context, :pub)
    :ok = :erlzmq.bind(publisher, 'tcp://*:5556')
    loop(publisher)
    :ok = :erlzmq.close(publisher)
    :ok = :erlzmq.term(context)
  end


  def loop(publisher) do
    zipcode = :random.uniform(100000)
    temperature = :random.uniform(215) - 80
    relhumidity = :random.uniform(50) + 10
    msg = :erlang.list_to_binary(:io_lib.format('~5..0b ~b ~b', [zipcode, temperature, relhumidity]))
    :ok = :erlzmq.send(publisher, msg)
    loop(publisher)
  end

end

Wuserver.main(:ok)

// 
//   Weather update server
//   Binds PUB socket to tcp://*:5556
//   Publishes random weather updates
// 
package main

import (
	"fmt"
	zmq "github.com/alecthomas/gozmq"
	"math/rand"
	"time"
)

func main() {
	context, _ := zmq.NewContext()
	socket, _ := context.NewSocket(zmq.PUB)
	defer context.Close()
	defer socket.Close()
	socket.Bind("tcp://*:5556")
	socket.Bind("ipc://weather.ipc")

	// Seed the random number generator
	rand.Seed(time.Now().UnixNano())

	// loop for a while aparently
	for {

		//  make values that will fool the boss
		zipcode := rand.Intn(100000)
		temperature := rand.Intn(215) - 80
		relhumidity := rand.Intn(50) + 10

		msg := fmt.Sprintf("%d %d %d", zipcode, temperature, relhumidity)

		//  Send message to all subscribers
		socket.Send([]byte(msg), 0)
	}
}

{-# LANGUAGE ScopedTypeVariables #-}

--  Weather update server
--  Binds PUB socket to tcp://*:5556
--  Publishes random weather updates

module Main where

import           Control.Monad
import qualified Data.ByteString.Char8 as BS
import           System.Random
import           System.ZMQ4.Monadic
import           Text.Printf

main :: IO ()
main = runZMQ $ do
    -- Prepare our publisher
    publisher <- socket Pub
    bind publisher "tcp://*:5556"

    forever $ do
        -- Get values that will fool the boss
        zipcode     :: Int <- liftIO $ randomRIO (0, 100000)
        temperature :: Int <- liftIO $ randomRIO (-30, 135)
        relhumidity :: Int <- liftIO $ randomRIO (10, 60)

        -- Send message to all subscribers
        let update = printf "%05d %d %d" zipcode temperature relhumidity
        send publisher [] (BS.pack update)

package ;
import haxe.io.Bytes;
import neko.Lib;
import org.zeromq.ZMQ;
import org.zeromq.ZMQContext;
import org.zeromq.ZMQSocket;

/**
 * Weather update server in Haxe
 * Binds PUB socket to tcp://*:5556
 * Publishes random weather updates
 * 
 * See: https://zguide.zeromq.cn/page:all#Getting-the-Message-Out
 * 
 * Use with WUClient.hx
 */
class WUServer 
{

	public static function main() {
		var context:ZMQContext = ZMQContext.instance();
		
		Lib.println("** WUServer (see: https://zguide.zeromq.cn/page:all#Getting-the-Message-Out)");

		var publisher:ZMQSocket = context.socket(ZMQ_PUB);
		publisher.bind("tcp://127.0.0.1:5556");
		
		while (true) {
			// Get values that will fool the boss
			var zipcode, temperature, relhumidity;           
			zipcode = Std.random(100000) + 1;
			temperature = Std.random(215) - 80 + 1;
			relhumidity = Std.random(50) + 10 + 1;
			
			// Send message to all subscribers
			var update:String = zipcode + " " + temperature + " " + relhumidity;
			publisher.sendMsg(Bytes.ofString(update));
		}
	}
}

package guide;

import java.util.Random;

import org.zeromq.SocketType;
import org.zeromq.ZMQ;
import org.zeromq.ZContext;

//
//  Weather update server in Java
//  Binds PUB socket to tcp://*:5556
//  Publishes random weather updates
//
public class wuserver
{
    public static void main(String[] args) throws Exception
    {
        //  Prepare our context and publisher
        try (ZContext context = new ZContext()) {
            ZMQ.Socket publisher = context.createSocket(SocketType.PUB);
            publisher.bind("tcp://*:5556");
            publisher.bind("ipc://weather");

            //  Initialize random number generator
            Random srandom = new Random(System.currentTimeMillis());
            while (!Thread.currentThread().isInterrupted()) {
                //  Get values that will fool the boss
                int zipcode, temperature, relhumidity;
                zipcode = 10000 + srandom.nextInt(10000);
                temperature = srandom.nextInt(215) - 80 + 1;
                relhumidity = srandom.nextInt(50) + 10 + 1;

                //  Send message to all subscribers
                String update = String.format(
                    "%05d %d %d", zipcode, temperature, relhumidity
                );
                publisher.send(update, 0);
            }
        }
    }
}

#!/usr/bin/env julia

#
#   Weather update server
#   Binds PUB socket to tcp://*:5556
#   Publishes random weather updates
#

using ZMQ

context = Context()
socket = Socket(context, PUB)
bind(socket, "tcp://*:5556")

while true
    zipcode = rand(10000:99999)
    temperature = rand(-80:135)
    relhumidity = rand(10:60)
    message = "$zipcode $temperature $relhumidity"
    send(socket, message)
    yield()
end

close(socket)
close(context)

--
--  Weather update server
--  Binds PUB socket to tcp://*:5556
--  Publishes random weather updates
--
--  Author: Robert G. Jakabosky <bobby@sharedrealm.com>
--
require"zmq"

--  Prepare our context and publisher
local context = zmq.init(1)
local publisher = context:socket(zmq.PUB)
publisher:bind("tcp://*:5556")
publisher:bind("ipc://weather.ipc")

--  Initialize random number generator
math.randomseed(os.time())
while (1) do
    --  Get values that will fool the boss
    local zipcode, temperature, relhumidity
    zipcode     = math.random(0, 99999)
    temperature = math.random(-80, 135)
    relhumidity = math.random(10, 60)

    --  Send message to all subscribers
    publisher:send(string.format("%05d %d %d", zipcode, temperature, relhumidity))
end
publisher:close()
context:term()

// Weather update server in node.js
// Binds PUB socket to tcp://*:5556
// Publishes random weather updates

var zmq = require('zeromq')
  , publisher = zmq.socket('pub');

publisher.bindSync("tcp://*:5556");
publisher.bindSync("ipc://weather.ipc");

function zeropad(num) {
  return num.toString().padStart(5, "0");
};

function rand(upper, extra) {
  var num = Math.abs(Math.round(Math.random() * upper));
  return num + (extra || 0);
};

while (true) {
  // Get values that will fool the boss
  var zipcode     = rand(100000)
    , temperature = rand(215, -80)
    , relhumidity = rand(50, 10)
    , update      = `${zeropad(zipcode)} ${temperature} ${relhumidity}`;
  publisher.send(update);
}

//
//  Weather update server
//  Binds PUB socket to tcp://*:5556
//  Publishes random weather updates
//
#import "ZMQObjC.h"
#import "ZMQHelper.h"

int
main(void)
{
	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

	//  Prepare our context and publisher
	ZMQContext *ctx = [[[ZMQContext alloc] initWithIOThreads:1U] autorelease];
	ZMQSocket *publisher = [ctx socketWithType:ZMQ_PUB];
	[publisher bindToEndpoint:@"tcp://*:5556"];
	[publisher bindToEndpoint:@"ipc://weather.ipc"];

	//  Initialize random number generator
	srandom ((unsigned) time (NULL));
	for (;;) {
		//  Get values that will fool the boss
		int zipcode, temperature, relhumidity;
		zipcode     = within (100000);
		temperature = within (215) - 80;
		relhumidity = within (50) + 10;

		// Send message to all subscribers
		NSString *update = [NSString stringWithFormat:@"%05d %d %d",
				zipcode, temperature, relhumidity];
		NSData *data = [update dataUsingEncoding:NSUTF8StringEncoding];
		[publisher sendData:data withFlags:0];
	}
	[publisher close];
	[pool drain];
	return EXIT_SUCCESS;
}

# Weather update server in Perl
# Binds PUB socket to tcp://*:5556
# Publishes random weather updates

use strict;
use warnings;

use ZMQ::FFI;
use ZMQ::FFI::Constants qw(ZMQ_PUB);

my $context   = ZMQ::FFI->new();
my $publisher = $context->socket(ZMQ_PUB);
$publisher->bind("tcp://*:5556");

my ($update, $zipcode, $temperature, $relhumidity);

while (1) {
    $zipcode     = rand(100_000);
    $temperature = rand(215) - 80;
    $relhumidity = rand(50) + 10;

    $update = sprintf('%d %d %d', $zipcode,$temperature,$relhumidity);

    $publisher->send($update);
}

<?php
/*
 *  Weather update server
 *  Binds PUB socket to tcp://*:5556
 *  Publishes random weather updates
 * @author Ian Barber <ian(dot)barber(at)gmail(dot)com>
 */

//  Prepare our context and publisher
$context = new ZMQContext();
$publisher = $context->getSocket(ZMQ::SOCKET_PUB);
$publisher->bind("tcp://*:5556");
$publisher->bind("ipc://weather.ipc");

while (true) {
    //  Get values that will fool the boss
    $zipcode     = mt_rand(0, 100000);
    $temperature = mt_rand(-80, 135);
    $relhumidity = mt_rand(10, 60);

    //  Send message to all subscribers
    $update = sprintf ("%05d %d %d", $zipcode, $temperature, $relhumidity);
    $publisher->send($update);
}

#
#   Weather update server
#   Binds PUB socket to tcp://*:5556
#   Publishes random weather updates
#

import zmq
from random import randrange


context = zmq.Context()
socket = context.socket(zmq.PUB)
socket.bind("tcp://*:5556")

while True:
    zipcode = randrange(1, 100000)
    temperature = randrange(-80, 135)
    relhumidity = randrange(10, 60)

    socket.send_string(f"{zipcode} {temperature} {relhumidity}")

#lang racket
#|
#   Weather update server
#   Binds PUB socket to tcp://*:5556
#   Publishes random weather updates
|#
(require net/zmq)

(define ctxt (context 1))
(define sock (socket ctxt 'PUB))
(socket-bind! sock "tcp://*:5556")

(let loop ()
  (define zipcode (random 100000))
  (define temp (- (random 215) 80))
  (define humidity (+ (random 50) 10))
  
  (socket-send! sock (string->bytes/utf-8 (format "~a ~a ~a" zipcode temp humidity)))
  
  (loop))

(context-close! ctxt)

#!/usr/bin/env ruby

#
# Weather update server in Ruby
# Binds PUB socket to tcp://*:5556
# Publishes random weather updates
#

require 'rubygems'
require 'ffi-rzmq'

context = ZMQ::Context.new(1)
publisher = context.socket(ZMQ::PUB)
publisher.bind("tcp://*:5556")
publisher.bind("ipc://weather.ipc")

while true
  # Get values that will fool the boss
  zipcode = rand(100000)
  temperature = rand(215) - 80
  relhumidity = rand(50) + 10

  update = "%05d %d %d" % [zipcode, temperature, relhumidity]
  puts update
  publisher.send_string(update)
end

use rand::Rng;

fn main() {
    let context = zmq::Context::new();
    let publisher = context.socket(zmq::PUB).unwrap();
    assert!(publisher.bind("tcp://*:5556").is_ok());

    let mut rng = rand::thread_rng();

    loop {
        let zipcode = rng.gen_range(0..100000);
        let temperature = rng.gen_range(-80..135);
        let relhumidity = rng.gen_range(10..60);

        let update = format!("{:05} {} {}", zipcode, temperature, relhumidity);
        publisher.send(&update, 0).unwrap();
    }
}

//
//  Weather update server in Scala
//  Binds PUB socket to tcp://*:5556
//  Publishes random weather updates
//
//  author Giovanni Ruggiero
//  email giovanni.ruggiero@gmail.com

import java.util.Random
import org.zeromq.ZMQ

object wuserver {
  def main(args : Array[String]) {

		//  Prepare our context and publisher
		val context = ZMQ.context(1)
		val publisher = context.socket(ZMQ.PUB)

		publisher.bind("tcp://*:5556")

		//  Initialize random number generator
		val srandom = new Random(System.currentTimeMillis())
		while (true) {
			//  Get values that will fool the boss
			val zipcode: Integer = srandom.nextInt(100000) + 1
			val temperature: Integer = srandom.nextInt(215) - 80 + 1
			val relhumidity: Integer = srandom.nextInt(50) + 10 + 1

			//  Send message to all subscribers
			val update = String.format("%05d %d %d\u0000", zipcode, temperature, relhumidity);
			publisher.send(update.getBytes(), 0)
		}
	}
}

#
# Weather update server
# Binds PUB socket to tcp:#*:5556
# Publishes random weather updates
#

package require zmq

# Prepare our context and publisher
zmq context context
zmq socket publisher context PUB
publisher bind "tcp://*:5556"
publisher bind "ipc://weather.ipc"

# Initialize random number generator
expr {srand([clock seconds])}

while {1} {
    # Get values that will fool the boss
    set zipcode [expr {int(rand()*100000)}]
    set temperature [expr {int(rand()*215)-80}]
    set relhumidity [expr {int(rand()*50)+50}]
    # Send message to all subscribers
    set data [format "%05d %d %d" $zipcode $temperature $relhumidity]
    if {$zipcode eq "10001"} {
	puts $data
    }
    zmq message msg -data $data
    publisher send_msg msg
    msg close
}

publisher close
context term

(**
  Weather update server
  Binds PUB socket to tcp://*:5556
  Publishes random weather updates
*)

open Zmq
open Helpers

let () =
  with_context @@ fun ctx ->
  with_socket ctx Socket.pub @@ fun pub ->
  Socket.bind pub "tcp://*:5556";
  Socket.bind pub "ipc://weather.ipc";
  Random.self_init ();
  while not !should_exit do
    (* Get values that will fool the boss *)
    let zipcode = Random.int 100_000 in
    let temperature = Random.int 215 - 80 in
    let relhumidity = Random.int 50 + 10 in
    (* Send message to all subscribers *)
    Socket.send pub (Printf.sprintf "%05d %d %d" zipcode temperature relhumidity);
  done

//  Weather update client
//  Connects SUB socket to tcp://localhost:5556
//  Collects weather updates and finds avg temp in zipcode

#include "zhelpers.h"

int main (int argc, char *argv [])
{
    //  Socket to talk to server
    printf ("Collecting updates from weather server...\n");
    void *context = zmq_ctx_new ();
    void *subscriber = zmq_socket (context, ZMQ_SUB);
    int rc = zmq_connect (subscriber, "tcp://localhost:5556");
    assert (rc == 0);

    //  Subscribe to zipcode, default is NYC, 10001
    const char *filter = (argc > 1)? argv [1]: "10001 ";
    rc = zmq_setsockopt (subscriber, ZMQ_SUBSCRIBE,
                         filter, strlen (filter));
    assert (rc == 0);

    //  Process 100 updates
    int update_nbr;
    long total_temp = 0;
    for (update_nbr = 0; update_nbr < 100; update_nbr++) {
        char *string = s_recv (subscriber);

        int zipcode, temperature, relhumidity;
        sscanf (string, "%d %d %d",
            &zipcode, &temperature, &relhumidity);
        total_temp += temperature;
        free (string);
    }
    printf ("Average temperature for zipcode '%s' was %dF\n",
        filter, (int) (total_temp / update_nbr));

    zmq_close (subscriber);
    zmq_ctx_destroy (context);
    return 0;
}

//
//  Weather update client in C++
//  Connects SUB socket to tcp://localhost:5556
//  Collects weather updates and finds avg temp in zipcode
//

#include <zmq.hpp>
#include <iostream>
#include <sstream>

int main (int argc, char *argv[])
{
    zmq::context_t context (1);

    //  Socket to talk to server
    std::cout << "Collecting updates from weather server...\n" << std::endl;
    zmq::socket_t subscriber (context, zmq::socket_type::sub);
    subscriber.connect("tcp://localhost:5556");

    //  Subscribe to zipcode, default is NYC, 10001
	const char *filter = (argc > 1)? argv [1]: "10001 ";
    subscriber.set(zmq::sockopt::subscribe, filter);

    //  Process 100 updates
    int update_nbr;
    long total_temp = 0;
    for (update_nbr = 0; update_nbr < 100; update_nbr++) {

        zmq::message_t update;
        int zipcode, temperature, relhumidity;

        subscriber.recv(update, zmq::recv_flags::none);

        std::istringstream iss(static_cast<char*>(update.data()));
		iss >> zipcode >> temperature >> relhumidity ;

		total_temp += temperature;
    }
    std::cout 	<< "Average temperature for zipcode '"<< filter
    			<<"' was "<<(int) (total_temp / update_nbr) <<"F"
    			<< std::endl;
    return 0;
}

;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
;;;
;;;  Weather update client in Common Lisp
;;;  Connects SUB socket to tcp://localhost:5556
;;;  Collects weather updates and finds avg temp in zipcode
;;;
;;; Kamil Shakirov <kamils80@gmail.com>
;;;

(defpackage #:zguide.wuclient
  (:nicknames #:wuclient)
  (:use #:cl #:zhelpers)
  (:export #:main))

(in-package :zguide.wuclient)

(defun main ()
  (zmq:with-context (context 1)
    (message "Collecting updates from weather server...~%")

    ;; Socket to talk to server
    (zmq:with-socket (subscriber context zmq:sub)
      (zmq:connect subscriber "tcp://localhost:5556")

      ;; Subscribe to zipcode, default is NYC, 10001
      (let ((filter (or (first (cmd-args)) "10001 ")))
        (zmq:setsockopt subscriber zmq:subscribe filter)

        ;; Process 100 updates
        (let ((number-updates 100)
              (total-temp 0.0))

          (loop :repeat number-updates :do
            (let ((update (make-instance 'zmq:msg)))
              (zmq:recv subscriber update)

              (destructuring-bind (zipcode_ temperature relhumidity_)
                  (split-sequence:split-sequence #\Space (zmq:msg-data-as-string update))

                (declare (ignore zipcode_ relhumidity_))
                (incf total-temp (parse-integer temperature)))))

          (message "Average temperature for zipcode ~A was ~FF~%"
                   filter (/ total-temp number-updates))))))

  (cleanup))

#! /usr/bin/env escript
%%
%% Weather update client
%% Connects SUB socket to tcp://localhost:5556
%% Collects weather updates and fins avg temp in zipcode
%%

main(Args) ->
    application:start(chumak),
    {ok, Subscriber} = chumak:socket(sub),

    %% select default topic or from the args
    Topic = case Args of
            [] -> <<"10001">>;
            [Arg1 | _] -> list_to_binary(Arg1)
        end,
    io:format("Collecting updates from weather server...~n"),
    io:format("For zipcode: ~p\n", [Topic]),
    chumak:subscribe(Subscriber, Topic),
    case chumak:connect(Subscriber, tcp, "localhost", 5556) of
        {ok, _BindPid} ->
            io:format("Binding OK with Pid: ~p\n", [Subscriber]);
        {error, Reason} ->
            io:foramt("Connection failed for this reason: ~p\n", [Reason]);
        X ->
            io:format("Unhandled reply for bind ~p \n", [X])
    end,

    N = 10, %% number of records to collect
    TotalTemp = collect_temperature(Subscriber, N, 0),
    io:format("Average Temperature is ~p\n", [TotalTemp/N]).


collect_temperature(_Subscriber, 0, Total) -> Total;
collect_temperature(Subscriber, N, Total) when N > 0 ->
    {ok, Data} = chumak:recv(Subscriber),
    io:format("RECEIVED : ~p\n", [Data]),
    [_, Temp, _] = string:split(Data, " ", all),
    IntTemp = erlang:binary_to_integer(Temp),
    collect_temperature(Subscriber, N-1, Total + IntTemp).

defmodule Wuclient do
  @moduledoc """
  Generated by erl2ex (http://github.com/dazuma/erl2ex)
  From Erlang source: (Unknown source file)
  At: 2019-12-20 13:57:39

  """

  def main(args) do
    {:ok, context} = :erlzmq.context()
    :io.format('Collecting updates from weather server...~n')
    {:ok, subscriber} = :erlzmq.socket(context, :sub)
    :ok = :erlzmq.connect(subscriber, 'tcp://localhost:5556')
    filter = case(args) do
      [] ->
        "10001"
      [arg1 | _] ->
        :erlang.list_to_binary(arg1)
    end
    :ok = :erlzmq.setsockopt(subscriber, :subscribe, filter)
    updateNbr = 5
    totalTemp = collect_temperature(subscriber, updateNbr, 0)
    :io.format('Average temperature for zipcode \'~s\' was ~bF~n', [filter, trunc(totalTemp / updateNbr)])
    :ok = :erlzmq.close(subscriber)
    :ok = :erlzmq.term(context)
  end


  def collect_temperature(_subscriber, 0, total) do
    total
  end

  def collect_temperature(subscriber, n, total) when n > 0 do
    {:ok, msg} = :erlzmq.recv(subscriber)
    collect_temperature(subscriber, n - 1, total + msg_temperature(msg))
  end


  def msg_temperature(msg) do
    {:ok, [_, temp, _], _} = :io_lib.fread('~d ~d ~d', :erlang.binary_to_list(msg))
    temp
  end

end

Wuclient.main([])

// 
//   Weather proxy listens to weather server which is constantly
//   emitting weather data
//   Binds SUB socket to tcp://*:5556
// 
package main

import (
	"fmt"
	zmq "github.com/alecthomas/gozmq"
	"os"
	"strconv"
	"strings"
)

func main() {
	context, _ := zmq.NewContext()
	socket, _ := context.NewSocket(zmq.SUB)
	defer context.Close()
	defer socket.Close()

	var temps []string
	var err error
	var temp int64
	total_temp := 0
	filter := "59937"

	// find zipcode
	if len(os.Args) > 1 { // ./wuclient 85678
		filter = string(os.Args[1])
	}

	//  Subscribe to just one zipcode (whitefish MT 59937) 
	fmt.Printf("Collecting updates from weather server for %s…\n", filter)
	socket.SetSubscribe(filter)
	socket.Connect("tcp://localhost:5556")

	for i := 0; i < 101; i++ {
		// found temperature point
		datapt, _ := socket.Recv(0)
		temps = strings.Split(string(datapt), " ")
		temp, err = strconv.ParseInt(temps[1], 10, 64)
		if err == nil {
			// Invalid string 
			total_temp += int(temp)
		}
	}

	fmt.Printf("Average temperature for zipcode %s was %dF \n\n", filter, total_temp/100)
}

{-# LANGUAGE LambdaCase          #-}
{-# LANGUAGE OverloadedStrings   #-}
{-# LANGUAGE ScopedTypeVariables #-}

--  Weather update client
--  Connects SUB socket to tcp://localhost:5556
--  Collects weather updates and finds avg temp in zipcode

module Main where

import           Control.Monad
import qualified Data.ByteString.Char8 as BS
import           System.Environment
import           System.ZMQ4.Monadic
import           Text.Printf

main :: IO ()
main = runZMQ $ do
    liftIO $ putStrLn "Collecting updates from weather server..."

    -- Socket to talk to server
    subscriber <- socket Sub
    connect subscriber "tcp://localhost:5556"

    -- Subscribe to zipcode, default is NYC, 10001
    filter <- liftIO getArgs >>= \case
        []          -> return "10001 "
        (zipcode:_) -> return (BS.pack zipcode)
    subscribe subscriber filter

    -- Process 100 updates
    temperature <- fmap sum $
        replicateM 100 $ do
            string <- receive subscriber
            let [_, temperature :: Int, _] = map read . words . BS.unpack $ string
            return temperature

    liftIO $
        printf "Average temperature for zipcode '%s' was %dF"
               (BS.unpack filter)
               (temperature `div` 100)

package ;
import haxe.io.Bytes;
import neko.Lib;
import neko.Sys;
import org.zeromq.ZMQ;
import org.zeromq.ZMQContext;
import org.zeromq.ZMQException;
import org.zeromq.ZMQSocket;

/**
 * Weather update client in Haxe
 * Connects SUB socket to tcp://localhost:5556
 * Collects weather updates and finds average temp in zipcode
 * 
 * Use optional argument to specify zip code (in range 1 to 100000)
 * 
 * See: https://zguide.zeromq.cn/page:all#Getting-the-Message-Out
 * 
 * Use with WUServer.hx
 */
class WUClient 
{

	public static function main() {
		var context:ZMQContext = ZMQContext.instance();
		
		Lib.println("** WUClient (see: https://zguide.zeromq.cn/page:all#Getting-the-Message-Out)");
		
		// Socket to talk to server
		trace ("Collecting updates from weather server...");
		var subscriber:ZMQSocket = context.socket(ZMQ_SUB);
		subscriber.setsockopt(ZMQ_LINGER, 0);	 // Don't block when closing socket at end
		
		subscriber.connect("tcp://localhost:5556");
		
		// Subscribe to zipcode, default in NYC, 10001
		var filter:String = 
			if (Sys.args().length > 0) {
				Sys.args()[0];
			} else {
				"10001";
			};
				
		try {
			subscriber.setsockopt(ZMQ_SUBSCRIBE, Bytes.ofString(filter));
		} catch (e:ZMQException) {
			trace (e.str());
		}
		
		// Process 100 updates
		var update_nbr = 0;
		var total_temp:Int = 0;
		for (update_nbr in 0...100) {
			var msg:Bytes = subscriber.recvMsg();
			trace (update_nbr+ ". Received: " + msg.toString());
			
			var zipcode, temperature, relhumidity;
			
			var sscanf:Array<String> = msg.toString().split(" ");
			zipcode = sscanf[0];
			temperature = sscanf[1];
			relhumidity = sscanf[2];
			total_temp += Std.parseInt(temperature);
			
		}
		trace ("Average temperature for zipcode " + filter + " was " + total_temp / 100);
		
		// Close gracefully
		subscriber.close();
		context.term();
	}
}

package guide;

import java.util.StringTokenizer;

import org.zeromq.SocketType;
import org.zeromq.ZMQ;
import org.zeromq.ZContext;

//
//  Weather update client in Java
//  Connects SUB socket to tcp://localhost:5556
//  Collects weather updates and finds avg temp in zipcode
//
public class wuclient
{
    public static void main(String[] args)
    {
        try (ZContext context = new ZContext()) {
            //  Socket to talk to server
            System.out.println("Collecting updates from weather server");
            ZMQ.Socket subscriber = context.createSocket(SocketType.SUB);
            subscriber.connect("tcp://localhost:5556");

            //  Subscribe to zipcode, default is NYC, 10001
            String filter = (args.length > 0) ? args[0] : "10001 ";
            subscriber.subscribe(filter.getBytes(ZMQ.CHARSET));

            //  Process 100 updates
            int update_nbr;
            long total_temp = 0;
            for (update_nbr = 0; update_nbr < 100; update_nbr++) {
                //  Use trim to remove the tailing '0' character
                String string = subscriber.recvStr(0).trim();

                StringTokenizer sscanf = new StringTokenizer(string, " ");
                int zipcode = Integer.valueOf(sscanf.nextToken());
                int temperature = Integer.valueOf(sscanf.nextToken());
                int relhumidity = Integer.valueOf(sscanf.nextToken());

                total_temp += temperature;
            }

            System.out.println(
                String.format(
                    "Average temperature for zipcode '%s' was %d.",
                    filter,
                    (int)(total_temp / update_nbr)
                )
            );
        }
    }
}

#!/usr/bin/env julia

#
#   Weather update client
#   Connects SUB socket to tcp://localhost:5556
#   Collects weather updates and finds avg temp in zipcode
#

using ZMQ

context = Context()
socket = Socket(context, SUB)

println("Collecting updates from weather server...")
connect(socket, "tcp://localhost:5556")

# Subscribe to zipcode, default is NYC, 10001
zip_filter = length(ARGS) > 0 ? int(ARGS[1]) : 10001

subscribe(socket, string(zip_filter))

# Process 5 updates
update_nbr = 5

total_temp = 0
for update in 1:update_nbr
    global total_temp
    message = unsafe_string(recv(socket))
    zipcode, temperature, relhumidity = split(message)
    total_temp += parse(Int, temperature)
end

avg_temp = total_temp / update_nbr

println("Average temperature for zipcode $zip_filter was $(avg_temp)F")

# Making a clean exit.
close(socket)
close(context)

--
--  Weather update client
--  Connects SUB socket to tcp://localhost:5556
--  Collects weather updates and finds avg temp in zipcode
--
--  Author: Robert G. Jakabosky <bobby@sharedrealm.com>
--
require"zmq"

local context = zmq.init(1)

--  Socket to talk to server
print("Collecting updates from weather server...")
local subscriber = context:socket(zmq.SUB)
subscriber:connect(arg[2] or "tcp://localhost:5556")

--  Subscribe to zipcode, default is NYC, 10001
local filter = arg[1] or "10001 "
subscriber:setopt(zmq.SUBSCRIBE, filter)

--  Process 100 updates
local update_nbr = 0
local total_temp = 0
for n=1,100 do
    local message = subscriber:recv()
    local zipcode, temperature, relhumidity = message:match("([%d-]*) ([%d-]*) ([%d-]*)")
    total_temp = total_temp + temperature
    update_nbr = update_nbr + 1
end
print(string.format("Average temperature for zipcode '%s' was %dF, total = %d",
    filter, (total_temp / update_nbr), total_temp))

subscriber:close()
context:term()

// weather update client in node.js
// connects SUB socket to tcp://localhost:5556
// collects weather updates and finds avg temp in zipcode

var zmq = require('zeromq');

console.log("Collecting updates from weather server...");

// Socket to talk to server
var subscriber = zmq.socket('sub');

// Subscribe to zipcode, default is NYC, 10001
var filter = null;
if (process.argv.length > 2) {
  filter = process.argv[2];
} else {
  filter = "10001";
}
console.log(filter);
subscriber.subscribe(filter);

// process 100 updates
var total_temp = 0
  , temps      = 0;
subscriber.on('message', function(data) {
  var pieces      = data.toString().split(" ")
    , zipcode     = parseInt(pieces[0], 10)
    , temperature = parseInt(pieces[1], 10)
    , relhumidity = parseInt(pieces[2], 10);

  temps += 1;
  total_temp += temperature;

  if (temps === 100) {
    console.log([
      "Average temperature for zipcode '",
      filter,
      "' was ",
      (total_temp / temps).toFixed(2),
      " F"].join(""));
    total_temp = 0;
    temps = 0;
  }
});

subscriber.connect("tcp://localhost:5556");

//
//  Weather update client
//  Connects SUB socket to tcp://localhost:5556
//  Collects weather updates and finds avg temp in zipcode
//
#import "ZMQObjC.h"

int
main(int argc, const char *argv[])
{
	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
	ZMQContext *ctx = [[[ZMQContext alloc] initWithIOThreads:1U] autorelease];

	// Socket to talk to server
	ZMQSocket *subscriber = [ctx socketWithType:ZMQ_SUB];
	if (![subscriber connectToEndpoint:@"tcp://localhost:5556"]) {
		/* ZMQSocket will already have logged the error. */
		return EXIT_FAILURE;
	}

	/* Subscribe to zipcode (defaults to NYC, 10001). */
	const char *kNYCZipCode = "10001";
	const char *filter = (argc > 1)? argv[1] : kNYCZipCode;
	NSData *filterData = [NSData dataWithBytes:filter length:strlen(filter)];
	[subscriber setData:filterData forOption:ZMQ_SUBSCRIBE];

	/* Write to stdout immediately rather than at each newline.
	 * This makes the incremental temperatures appear incrementally.
	 */
	(void)setvbuf(stdout, NULL, _IONBF, BUFSIZ);

	/* Process updates. */
	NSLog(@"Collecting temperatures for zipcode %s from weather server...", filter);
	const int kMaxUpdate = 100;
	long total_temp = 0;
	for (int update_nbr = 0; update_nbr < kMaxUpdate; ++update_nbr) {
		NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

		NSData *msg = [subscriber receiveDataWithFlags:0];
		const char *string = [msg bytes];

		int zipcode = 0, temperature = 0, relhumidity = 0;
		(void)sscanf(string, "%d %d %d", &zipcode, &temperature, &relhumidity);

		printf("%d ", temperature);
		total_temp += temperature;

		[pool drain];
	}
	/* End line of temperatures. */
	putchar('\n');

	NSLog(@"Average temperature for zipcode '%s' was %ld degF.",
			filter, total_temp / kMaxUpdate);

	/* [ZMQContext sockets] makes it easy to close all associated sockets. */
	[[ctx sockets] makeObjectsPerformSelector:@selector(close)];
	[pool drain];
	return EXIT_SUCCESS;
}

# Weather update client in Perl
# Connects SUB socket to tcp://localhost:5556
# Collects weather updates and finds avg temp in zipcode

use strict;
use warnings;
use v5.10;

use ZMQ::FFI;
use ZMQ::FFI::Constants qw(ZMQ_SUB);

# Socket to talk to server
say "Collecting updates from weather station...";

my $context    = ZMQ::FFI->new();
my $subscriber = $context->socket(ZMQ_SUB);
$subscriber->connect("tcp://localhost:5556");

# Subscribe to zipcode, default is NYC, 10001
my $filter = $ARGV[0] // "10001";
$subscriber->subscribe($filter);

# Process 100 updates
my $update_nbr = 100;
my $total_temp = 0;

my ($update, $zipcode, $temperature, $relhumidity);

for (1..$update_nbr) {
    $update = $subscriber->recv();

    ($zipcode, $temperature, $relhumidity) = split ' ', $update;
    $total_temp += $temperature;
}

printf "Average temperature for zipcode '%s' was %dF\n",
    $filter, $total_temp / $update_nbr;

<?php
/*
 *  Weather update client
 *  Connects SUB socket to tcp://localhost:5556
 *  Collects weather updates and finds avg temp in zipcode
 * @author Ian Barber <ian(dot)barber(at)gmail(dot)com>
 */

$context = new ZMQContext();

//  Socket to talk to server
echo "Collecting updates from weather server...", PHP_EOL;
$subscriber = new ZMQSocket($context, ZMQ::SOCKET_SUB);
$subscriber->connect("tcp://localhost:5556");

//  Subscribe to zipcode, default is NYC, 10001
$filter = $_SERVER['argc'] > 1 ? $_SERVER['argv'][1] : "10001";
$subscriber->setSockOpt(ZMQ::SOCKOPT_SUBSCRIBE, $filter);

//  Process 100 updates
$total_temp = 0;
for ($update_nbr = 0; $update_nbr < 100; $update_nbr++) {
    $string = $subscriber->recv();
    sscanf ($string, "%d %d %d", $zipcode, $temperature, $relhumidity);
    $total_temp += $temperature;
}
printf ("Average temperature for zipcode '%s' was %dF\n",
    $filter, (int) ($total_temp / $update_nbr));

#
#   Weather update client
#   Connects SUB socket to tcp://localhost:5556
#   Collects weather updates and finds avg temp in zipcode
#

import sys
import zmq


#  Socket to talk to server
context = zmq.Context()
socket = context.socket(zmq.SUB)

print("Collecting updates from weather server...")
socket.connect("tcp://localhost:5556")

# Subscribe to zipcode, default is NYC, 10001
zip_filter = sys.argv[1] if len(sys.argv) > 1 else "10001"
socket.setsockopt_string(zmq.SUBSCRIBE, zip_filter)

# Process 5 updates
total_temp = 0
for update_nbr in range(100):
    string = socket.recv_string()
    zipcode, temperature, relhumidity = string.split()
    total_temp += int(temperature)

print((f"Average temperature for zipcode " 
    f"'{zip_filter}' was {total_temp / (update_nbr+1)} F"))

#lang racket
#|
#   Weather update client
#   Connects SUB socket to tcp://localhost:5556
#   Collects weather updates and finds avg temp in zipcode
|#
(require net/zmq)

;  Socket to talk to server
(define ctxt (context 1))
(define sock (socket ctxt 'SUB))

(printf "Collecting updates from weather server...\n")
(socket-connect! sock "tcp://localhost:5556")

; Subscribe to zipcode, default is NYC, 10001
(define filter 
  (command-line #:program "wuclient" #:args maybe-zip 
                (match maybe-zip
                  [(list zipcode) zipcode]
                  [(list) "10001"]
                  [else (error 'wuclient "Incorrect argument list")])))
(set-socket-option! sock 'SUBSCRIBE (string->bytes/utf-8 filter))

; Process 5 updates
(define how-many 5)
(define total-temp
  (for/fold ([tot 0])
    ([i (in-range how-many)])
    (match-define (regexp #rx"([0-9]+) (-?[0-9]+) ([0-9]+)" (list _ zipcode temp humid))
                  (socket-recv! sock))
    (+ tot (string->number (bytes->string/utf-8 temp)))))

(printf "Average temperature for zipcode '~a' was ~a\n"
        filter (/ total-temp how-many))

(context-close! ctxt)

#!/usr/bin/env ruby

#
# Weather update client in Ruby
# Connects SUB socket to tcp://localhost:5556
# Collects weather updates and finds avg temp in zipcode
#

require 'rubygems'
require 'ffi-rzmq'

COUNT = 100

context = ZMQ::Context.new(1)

# Socket to talk to server
puts "Collecting updates from weather server..."
subscriber = context.socket(ZMQ::SUB)
subscriber.connect("tcp://localhost:5556")

# Subscribe to zipcode, default is NYC, 10001
filter = ARGV.size > 0 ? ARGV[0] : "10001 "
subscriber.setsockopt(ZMQ::SUBSCRIBE, filter)

# Process 100 updates
total_temp = 0
1.upto(COUNT) do |update_nbr|
  s = ''
  subscriber.recv_string(s)#.split.map(&:to_i)
  
  zipcode, temperature, relhumidity = s.split.map(&:to_i)
  total_temp += temperature
end

puts "Average temperature for zipcode '#{filter}' was #{total_temp / COUNT}F"

use std::env;

fn atoi(s: &str) -> i64 {
    s.parse().unwrap()
}

fn main() {
    println!("Collecting updates from weather server...");

    let context = zmq::Context::new();
    let subscriber = context.socket(zmq::SUB).unwrap();
    assert!(subscriber.connect("tcp://localhost:5556").is_ok());

    let args: Vec<String> = env::args().collect();
    let filter = if args.len() > 1 { &args[1] } else { "10001" };
    assert!(subscriber.set_subscribe(filter.as_bytes()).is_ok());

    let mut total_temp = 0;

    for _ in 0..100 {
        let string = subscriber.recv_string(0).unwrap().unwrap();
        let chks: Vec<i64> = string.split(' ').map(atoi).collect();
        let (_zipcode, temperature, _relhumidity) = (chks[0], chks[1], chks[2]);

        total_temp += temperature;
    }

    println!(
        "Average temperature for zipcode {} was {}F",
        filter,
        total_temp / 100
    );
}

/*
 *  Weather update client in Scala
 *  Connects SUB socket to tcp://localhost:5556
 *  Collects weather updates and finds avg temp in zipcode
 *
 * @author Giovanni Ruggiero
 * @email giovanni.ruggiero@gmail.com
*/

import java.util.StringTokenizer
import org.zeromq.ZMQ

object wuclient {

  def main(args : Array[String]) {
		val context = ZMQ.context(1)

		//  Socket to talk to server
		println("Collecting updates from weather server...")
		val subscriber = context.socket(ZMQ.SUB)
		subscriber.connect("tcp://localhost:5556")

		//  Subscribe to zipcode, default is NYC, 10001
		val filter = {if (args.length > 0)  args(0) else "10001 "}
		subscriber.subscribe(filter.getBytes())

		//  Process 100 updates
		val update_nbr = 100
		var total_temp = 0
		for (i <- 1 to update_nbr ) {
			//  Use trim to remove the tailing '0' character
			val sscanf = new String(subscriber.recv(0)).trim.split(' ').map(_.toInt)
			val zipcode = sscanf(0)
			val temperature = sscanf(1)
			val relhumidity = sscanf(2)
			total_temp += temperature
		}
		println("Average temperature for zipcode '" + filter + "' was " +  (total_temp / update_nbr))
	}
}

#
# Weather update client
# Connects SUB socket to tcp:#localhost:5556
# Collects weather updates and finds avg temp in zipcode
#

package require zmq

# Socket to talk to server
zmq context context
zmq socket subscriber context SUB
subscriber connect "tcp://localhost:5556"

# Subscribe to zipcode, default is NYC, 10001
if {[llength $argv]} {
    set filter [lindex $argv 0]
} else {
    set filter "10001"
}

subscriber setsockopt SUBSCRIBE $filter

# Process 100 updates
set total_temp 0
for {set update_nbr 0} {$update_nbr < 100} {incr update_nbr} {
    zmq message msg
    subscriber recv_msg msg
    lassign [msg data] zipcode temperature relhumidity
    puts [msg data]
    msg close
    incr total_temp $temperature
}

puts "Averate temperatur for zipcode $filter was [expr {$total_temp/$update_nbr}]F"

subscriber close
context term

(**
  Weather update client
  Connects SUB socket to tcp://localhost:5556
  Collects weather updates and finds avg temp in zipcode
*)

open Zmq
open Helpers

let () =
  with_context @@ fun ctx ->
  with_socket ctx Socket.sub @@ fun sub ->
  printfn "Collecting updates from weather server...";
  Socket.connect sub "tcp://localhost:5556";
  (* Subscribe to zipcode, default is NYC, 10001 *)
  let filter = match Array.to_list Sys.argv with _::zip::_ -> zip | _ -> "10001 " in
  Socket.subscribe sub filter;
  (* Process 100 updates *)
  let total_temp = ref 0 in
  for i = 0 to pred 100 do
    Scanf.sscanf (Socket.recv sub) "%d %d %d" begin fun _zipcode temperature _relhumidity ->
      total_temp := !total_temp + temperature
    end
  done;
  printfn "Average temperature for zipcode '%s' was %dF" filter (!total_temp / 100)

//  Task ventilator
//  Binds PUSH socket to tcp://localhost:5557
//  Sends batch of tasks to workers via that socket

#include "zhelpers.h"

int main (void) 
{
    void *context = zmq_ctx_new ();

    //  Socket to send messages on
    void *sender = zmq_socket (context, ZMQ_PUSH);
    zmq_bind (sender, "tcp://*:5557");

    //  Socket to send start of batch message on
    void *sink = zmq_socket (context, ZMQ_PUSH);
    zmq_connect (sink, "tcp://localhost:5558");

    printf ("Press Enter when the workers are ready: ");
    getchar ();
    printf ("Sending tasks to workers...\n");

    //  The first message is "0" and signals start of batch
    s_send (sink, "0");

    //  Initialize random number generator
    srandom ((unsigned) time (NULL));

    //  Send 100 tasks
    int task_nbr;
    int total_msec = 0;     //  Total expected cost in msecs
    for (task_nbr = 0; task_nbr < 100; task_nbr++) {
        int workload;
        //  Random workload from 1 to 100msecs
        workload = randof (100) + 1;
        total_msec += workload;
        char string [10];
        sprintf (string, "%d", workload);
        s_send (sender, string);
    }
    printf ("Total expected cost: %d msec\n", total_msec);

    zmq_close (sink);
    zmq_close (sender);
    zmq_ctx_destroy (context);
    return 0;
}

//
//  Task ventilator in C++
//  Binds PUSH socket to tcp://localhost:5557
//  Sends batch of tasks to workers via that socket
//

#include <zmq.hpp>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <iostream>

#define within(num) (int) ((float) num * random () / (RAND_MAX + 1.0))

int main (int argc, char *argv[])
{
    zmq::context_t context (1);

    //  Socket to send messages on
    zmq::socket_t  sender(context, ZMQ_PUSH);
    sender.bind("tcp://*:5557");

    std::cout << "Press Enter when the workers are ready: " << std::endl;
    getchar ();
    std::cout << "Sending tasks to workers...\n" << std::endl;

    //  The first message is "0" and signals start of batch
    zmq::socket_t sink(context, ZMQ_PUSH);
    sink.connect("tcp://localhost:5558");
    zmq::message_t message(2);
    memcpy(message.data(), "0", 1);
    sink.send(message);

    //  Initialize random number generator
    srandom ((unsigned) time (NULL));

    //  Send 100 tasks
    int task_nbr;
    int total_msec = 0;     //  Total expected cost in msecs
    for (task_nbr = 0; task_nbr < 100; task_nbr++) {
        int workload;
        //  Random workload from 1 to 100msecs
        workload = within (100) + 1;
        total_msec += workload;

        message.rebuild(10);
        memset(message.data(), '\0', 10);
        sprintf ((char *) message.data(), "%d", workload);
        sender.send(message);
    }
    std::cout << "Total expected cost: " << total_msec << " msec" << std::endl;
    sleep (1);              //  Give 0MQ time to deliver

    return 0;
}

;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; -*-
;;;
;;;  Task ventilator in Common Lisp
;;;  Binds PUSH socket to tcp://localhost:5557
;;;  Sends batch of tasks to workers via that socket
;;;
;;; Kamil Shakirov <kamils80@gmail.com>
;;;

(defpackage #:zguide.taskvent
  (:nicknames #:taskvent)
  (:use #:cl #:zhelpers)
  (:export #:main))

(in-package :zguide.taskvent)

(defun main ()
  (zmq:with-context (context 1)
    ;; Socket to send messages on
    (zmq:with-socket (sender context zmq:push)
      (zmq:bind sender "tcp://*:5557")

      (message "Press Enter when the workers are ready: ")
      (read-char)
      (message "Sending tasks to workers...~%")

      ;; The first message is "0" and signals start of batch
      (let ((msg (make-instance 'zmq:msg :data "0")))
        (zmq:send sender msg))

      ;; Send 100 tasks
      (let ((total-msec 0))
        (loop :repeat 100 :do
          ;; Random workload from 1 to 100 msecs
          (let ((workload (within 100)))
            (incf total-msec workload)
            (let ((msg (make-instance 'zmq:msg
                                      :data (format nil "~D" workload))))
              (zmq:send sender msg))))

        (message "Total expected cost: ~D msec~%" total-msec)
        ;; Give 0MQ time to deliver
        (sleep 1))))

  (cleanup))

#! /usr/bin/env escript
%%
%% Task ventilator
%% Binds PUSH socket to tcp://localhost:5557
%% Sends batch of tasks to workers via that socket
%%
main(_Args) ->
    application:start(chumak),
    {ok, Sender} = chumak:socket(push),
    
    case chumak:bind(Sender, tcp, "*", 5557) of
        {ok, _BindPid} ->
            io:format("Binding OK with Pid: ~p\n", [Sender]);
        {error, Reason} ->
            io:format("Connection Failed for this reason: ~p\n", [Reason]);
        X ->
            io:format("Unhandled reply for bind ~p\n", [X])
    end,

    {ok, Sink} = chumak:socket(push),

    case chumak:connect(Sink, tcp, "localhost", 5558) of
        {ok, _ConnectPid} ->
            io:format("Connection OK with Pid: ~p\n", [Sink]);
        {error, Reason2} ->
            io:format("Connection Failed for this reason: ~p\n", [Reason2]);
        X2 ->
            io:format("Unhandled reply for connect  ~p\n", [X2])
    end,

    {ok, _} = io:fread("Press Enter when workers are ready: ", ""),
    io:format("Sending task to workers~n", []),

    ok = chumak:send(Sink, <<"0">>),

    %% Send 100 tasks
    TotalCost = send_tasks(Sender, 100, 0),
    io:format("Total expected cost: ~b msec~n", [TotalCost]).


send_tasks(_Sender, 0, TotalCost) -> TotalCost;
send_tasks(Sender, N, TotalCost) when N>0 ->
    Workload = rand:uniform(100) + 1,
    ok = chumak:send(Sender, list_to_binary(integer_to_list(Workload))),
    send_tasks(Sender, N-1, TotalCost + Workload).

defmodule Taskvent do
  @moduledoc """
  Generated by erl2ex (http://github.com/dazuma/erl2ex)
  From Erlang source: (Unknown source file)
  At: 2019-12-20 13:57:36

  """

  def main() do
    {:ok, context} = :erlzmq.context()
    {:ok, sender} = :erlzmq.socket(context, :push)
    :ok = :erlzmq.bind(sender, 'tcp://*:5557')
    {:ok, sink} = :erlzmq.socket(context, :push)
    :ok = :erlzmq.connect(sink, 'tcp://localhost:5558')
    {:ok, _} = :io.fread('Press Enter when workers are ready: ', [])
    :io.format('Sending task to workers~n', [])
    :ok = :erlzmq.send(sink, "0")
    totalCost = send_tasks(sender, 100, 0)
    :io.format('Total expected cost: ~b msec~n', [totalCost])
    :ok = :erlzmq.close(sink)
    :ok = :erlzmq.close(sender)
    :erlzmq.term(context, 1000)
  end


  def send_tasks(_sender, 0, totalCost) do
    totalCost
  end

  def send_tasks(sender, n, totalCost) when n > 0 do
    workload = :random.uniform(100) + 1
    :ok = :erlzmq.send(sender, :erlang.list_to_binary(:erlang.integer_to_list(workload)))
    send_tasks(sender, n - 1, totalCost + workload)
  end

end

Taskvent.main

//
// Task ventilator
// Binds PUSH socket to tcp://localhost:5557
// Sends batch of tasks to workers via that socket
//
package main

import (
	"fmt"
	zmq "github.com/alecthomas/gozmq"
	"math/rand"
	"time"
)

func main() {
	context, _ := zmq.NewContext()
	defer context.Close()

	// Socket to send messages On
	sender, _ := context.NewSocket(zmq.PUSH)
	defer sender.Close()
	sender.Bind("tcp://*:5557")

	//  Socket to send start of batch message on
	sink, _ := context.NewSocket(zmq.PUSH)
	defer sink.Close()
	sink.Connect("tcp://localhost:5558")

	fmt.Print("Press Enter when the workers are ready: ")

	var line string
	fmt.Scanln(&line)

	fmt.Println("Sending tasks to workers…")

	sink.Send([]byte("0"), 0)

	// Seed the random number generator
	rand.Seed(time.Now().UnixNano())

	total_msec := 0

	for i := 0; i < 100; i++ {
		workload := rand.Intn(100)
		total_msec += workload
		msg := fmt.Sprintf("%d", workload)
		sender.Send([]byte(msg), 0)
	}

	fmt.Printf("Total expected cost: %d msec\n", total_msec)

	time.Sleep(1e9) //  Give 0MQ time to deliver: one second ==  1e9 ns

}