The difference is that a `PUB` socket sends the same message to **all** subscribers, whereas `PUSH` does a **round-robin** amongst all its connected `PULL` sockets.

In your example, if you send just a single message from the root, then all the subscribers will receive it (barring slow subscribers, etc.) but only 1 worker.

The pub/sub pattern is used for wide message distribution according to topics. The push/pull pattern is really a pipelining mechanism. Your push/pull example seems to be attempting to do load-balancing, which is fine, but req/rep might be better suited to that due to other issues.

It looks like the &quot;issues&quot; here are described in the same part of the 0MQ guide you got the image from : [push/pull ventilator example][1]


  [1]: https://zguide.zeromq.org/docs/chapter1/#Divide-and-Conquer

I know that has been asked before, but I find no clean way of overriding this CSS:

&lt;!-- language: lang-css --&gt;

    .ui-input-search:after {
        content: &quot;&quot;;
        height: 18px;
        left: 0.3125em;
        margin-top: -9px;
        opacity: 0.5;
        position: absolute;
        top: 50%;
        width: 18px;
    }

I need to leave `ui-input-search` on the element, but can add my own class, like:

&lt;!-- language: lang-css --&gt;

    .ui-input-search-no-pseudo:after {
       content: &quot;&quot;;
    }

**Question**:  
Is there an easy way to remove &quot;pseudo-css&quot; without having to overwrite the CSS line by line?

Thanks!

How do I override CSS set on a pseudo element?

[Here][1] is an example of IPython notebook in which besides the input and output cells we have a plain text. How can I do the same in my IPython notebook? At the moment I have inly `In` and `Out` cells.


  [1]: http://nbviewer.ipython.org/urls/raw.github.com/temporaer/tutorial_ml_gkbionics/master/2%2520-%2520KMeans.ipynb

How to write text in jupyter / ipython notebook?

This two images are from http://zguide.zeromq.org/page:all.

What is the difference between this two pattern if we ignore sink in push-pull pattern ?
Is there a difference in how a message gets transfer, if yes what is the difference ?

![](https://github.com/imatix/zguide/raw/master/images/fig4.png)
![](https://github.com/imatix/zguide/raw/master/images/fig5.png)


 

difference between pub-sub and push-pull pattern in zeroMq

This two images are from <a href="http://zguide.zeromq.org/page:all" target="_blank" rel="noopener noreferrer">http://zguide.zeromq.org/page:all</a>.
What is the difference between this two pattern if we ignore sink in push-pull pattern ?
Is there a difference in how a message gets transfer, if yes what is the difference ?
<img src="https://github.com/imatix/zguide/raw/master/images/fig4.png" alt="">
<img src="https://github.com/imatix/zguide/raw/master/images/fig5.png" alt="">

1. What are the allowed types of messages (strings, bytes, integers, etc.)?
2. What is the maximum size of a message?
3. What is the maximum number of queues and exchanges?

What are the limits of messages, queues and exchanges?

I&#39;ve been getting more into the internals of the Node.js architecture, and a term I see coming up a lot is &quot;tick&quot; as in &quot;next tick of the event loop&quot; or the function [nextTick()][1].

What I haven&#39;t seen is a solid definition of what exactly a &quot;tick&quot; is. Based on various articles ([such as this one][2]), I&#39;ve been able to piece a concept together in my head, but I&#39;m not sure how accurate it is.

Can I get a precise and detailed description of a Node.js event loop tick?

  [1]: http://nodejs.org/docs/latest/api/process.html#process_process_nexttick_callback
  [2]: http://howtonode.org/understanding-process-next-tick

What exactly is a Node.js event loop tick?

I need to choose a new Queue broker for my new project.  

This time I need a scalable queue that supports pub/sub, and keeping message ordering is a must.  

I read Alexis comment: He writes:

&gt; &quot;Indeed, we think RabbitMQ provides stronger ordering than Kafka&quot;

I read the message ordering section in rabbitmq docs:

    

&gt; &quot;Messages can be returned to the queue using AMQP methods that feature
&gt; a requeue
&gt;      parameter (basic.recover, basic.reject and basic.nack), or due to a channel 
&gt;      closing while holding unacknowledged messages...With release 2.7.0 and later 
&gt;      it is still possible for individual consumers to observe messages out of 
&gt;      order if the queue has multiple subscribers. This is due to the actions of 
&gt;      other subscribers who may requeue messages. From the perspective of the queue 
&gt;      the messages are always held in the publication order.&quot;

If I need to handle messages by their order, I can only use rabbitMQ with an exclusive queue to each consumer?  

Is RabbitMQ still considered a good solution for ordered message queuing?




RabbitMQ - Message order of delivery

What&#39;s the maximum number of queues that RabbitMQ can handle on a single server?

Does it depend on RAM? Does it depends on erlang processes?

RabbitMQ - How many queues can RabbitMQ handle on a single server?

I don&#39;t have any previous experience with *MQs and I&#39;m looking to build knowledge on JMS and message queues in general. That way, I wonder whether I should start with ActiveMQ or just &quot;ignore&quot; it altogether and start by teaching myself Apollo. Is Apollo as feature-complete as ActiveMQ? Does it implement JMS 2.0 (I see that ActiveMQ got stuck with 1.1)? Will I be missing something really important?

Also, how does Kafka compare to these two solutions?

ActiveMQ vs Apollo vs Kafka

I am confused as to what poller actually does in zmq. The zguide goes into it minimally, and only describes it as a way to read from multiple sockets. This is not a satisfying answer for me because it does not explain how to have timeout sockets. I know https://stackoverflow.com/questions/7538988/zeromq-how-to-prevent-infinite-wait explains for push/pull, but not req/rep patterns, which is what I want to know how to use.

What I am attempting to ask is: How does poller work, and how does its function apply to keeping track of sockets and their requests?

How does zmq poller work?

I&#39;d like to compare somehow capabilities of grpc vs. zeromq &amp; its patterns: and I&#39;d like to create some comparsion (feature set) - somehow - 0mq is &quot;better&quot; sockets - but anyways - if I apply 0mq patterns - I get comparable &#39;frameworks&#39; I think - and here 0mq seems to be much more flexible ...

The main requirements are:

 - async req / res communication (inproc or remote) between nodes
 - flexible messages routing 
 - loadbalancing support
 - well documented

any ideas? 

thanks!


grpc and zeromq comparsion

The [RabbitMQ Java client](http://www.rabbitmq.com/releases/rabbitmq-java-client/v3.1.5/rabbitmq-java-client-javadoc-3.1.5/) has the following concepts:

* `Connection` - a connection to a RabbitMQ server instance
* `Channel` - ???
* Consumer thread pool - a pool of threads that consume messages off the RabbitMQ server queues
* Queue - a structure that holds messages in FIFO order

I&#39;m trying to understand the relationship, **and more importantly**, the *associations* between them.

  1. I&#39;m still not quite sure what a `Channel` is, other than the fact that this is the structure that you publish and consume from, and that it is created from an open connection. If someone could explain to me what the &quot;Channel&quot; represents, it might help clear a few things up.
  2. What is the relationship between Channel and Queue? Can the same Channel be used to communicate to multiples Queues, or does it have to be 1:1?
  3. What is the relationship between Queue and the Consumer Pool? Can multiple Consumers be subscribed to the same Queue? Can multiple Queues be consumed by the same Consumer? Or is the relationship 1:1?

RabbitMQ and relationship between channel and connection

I just read [RabbitMQ&#39;s Java API docs](http://www.rabbitmq.com/api-guide.html), and found it very informative and straight-forward. The example for how to set up a simple `Channel` for publishing/consuming is very easy to follow and understand. But it&#39;s a very simple/basic example, and it left me with an important question: **How can I set up 1+ `Channels` to publish/consume to and from multiple queues?**

Let&#39;s say I have a RabbitMQ server with 3 queues on it: `logging`, `security_events` and `customer_orders`. So we&#39;d either need a single `Channel` to have the ability to publish/consume to all 3 queues, or more likely, have 3 separate `Channels`, each dedicated to a single queue.

On top of this, RabbitMQ&#39;s best practices dictate that we set up 1 `Channel` per consumer thread. For this example, let&#39;s say `security_events` is fine with only 1 consumer thread, but `logging` and `customer_order` both need 5 threads to handle the volume. So, if I understand correctly, does that mean we need:

* 1 `Channel` and 1 consumer thread for publishing/consuming to and from `security_events`; and
* 5 `Channels` and 5 consumer threads for publishing/consuming to and from `logging`; and
* 5 `Channels` and 5 consumer threads for publishing/consuming to and from `customer_orders`?

If my understanding is misguided here, please begin by correcting me. Either way, could some battle-weary RabbitMQ veteran **help me &quot;connect the dots&quot; with a decent code example for setting up publishers/consumers that meet my requirements here?** Thanks in advance!

RabbitMQ by Example: Multiple Threads, Channels and Queues

All of the [examples](https://www.google.com/#q=kafka+producer+key+value) of [Kafka](https://kafka.apache.org/090/javadoc/index.html?org/apache/kafka/clients/producer/KafkaProducer.html) | [producers](https://www.tutorialspoint.com/apache_kafka/apache_kafka_simple_producer_example.htm) show the `ProducerRecord`&#39;s key/value pair as not only being the same type (all examples show `&lt;String,String&gt;`), but the same **value**. For example:

    producer.send(new ProducerRecord&lt;String, String&gt;(&quot;someTopic&quot;, Integer.toString(i), Integer.toString(i)));

But in the Kafka docs, I can&#39;t seem to find where the key/value concept (and its underlying purpose/utility) is explained. In traditional messaging (ActiveMQ, RabbitMQ, etc.) I&#39;ve always fired a message at a particular topic/queue/exchange. But Kafka is the first broker that seems to require key/value pairs instead of just a regulare &#39;ole string message.

So I ask: **What is the purpose/usefulness of requiring producers to send KV pairs?**

What&#39;s the purpose of Kafka&#39;s key/value pair-based messaging?

What is the basic difference between stream processing and traditional message processing? As people say that kafka is good choice for stream processing but essentially kafka is a messaging framework similar to ActivMQ, RabbitMQ etc.

Why do we generally not say that ActiveMQ is good for stream processing as well.

Is it the speed at which messages are consumed by the consumer determines if it is a stream?

Content Type	Original Author	Original Content on Stackoverflow
Question	Bhuvan	View Question on Stackoverflow
Solution 1 - Message Queue	SteveLove	View Answer on Stackoverflow

difference between pub-sub and push-pull pattern in zeroMq

Message Queue Problem Overview

Message Queue Solutions

Solution 1 - Message Queue

How to write text in jupyter / ipython notebook?

How do I override CSS set on a pseudo element?

Attributions