I would like to use the code from the answer to this question:  https://stackoverflow.com/questions/6527321/how-to-observe-the-value-of-an-nstextfield on an NSTextField in order to observe changes on the string stored in the NSTextField.

    [[NSNotificationCenter defaultCenter]
        addObserverForName:NSTextViewDidChangeSelectionNotification
        object:self.textView 
        queue:[NSOperationQueue mainQueue] 
        usingBlock:^(NSNotification *note){
        NSLog(@&quot;Text: %@&quot;, self.textView.textStorage.string);
    }];

The class used here is an NSTextView. I can&#39;t find a notification in NSTextField to use instead of NSTextViewDidChangeSelectionNotification.

Is there a notification available in NSTextField that can be used in this case ?

Text change notification for an NSTextField

Are there any exemplary examples of the GoF Observer implemented in Python?  I have a bit code which currently has bits of debugging code laced through the key class (currently generating messages to stderr if a magic env is set). Additionally, the class has an interface for incrementally return results as well as storing them (in memory) for post processing.  (The class itself is a job manager for concurrently executing commands on remote machines over ssh).

Currently the usage of the class looks something like:

    job = SSHJobMan(hostlist, cmd)
    job.start()
    while not job.done():
        for each in job.poll():
            incrementally_process(job.results[each])
            time.sleep(0.2) # or other more useful work
    post_process(job.results)

An alernative usage model is:

    job = SSHJobMan(hostlist, cmd)
    job.wait()  # implicitly performs a start()
    process(job.results)

This all works fine for the current utility.  However it does lack flexibility.  For example I currently support a brief output format or a progress bar as incremental results, I also support
brief, complete and &quot;merged message&quot; outputs for the `post_process()` function.

However, I&#39;d like to support multiple results/output streams (progress bar to the terminal, debugging and warnings to a log file, outputs from successful jobs to one file/directory, error messages and other results from non-successful jobs to another, etc).

This sounds like a situation that calls for Observer ... have instances of my class accept registration from other objects and call them back with specific types of events as they occur.

I&#39;m looking at [PyPubSub](http://pypi.python.org/pypi/PyPubSub/) since I saw several references to that in SO related questions.  I&#39;m not sure I&#39;m ready to add the external dependency to my utility but I could see value in using their interface as a model for mine if that&#39;s going to make it easier for others to use.  (The project is intended as both a standalone command line utility and a class for writing other scripts/utilities).

In short I know how to do what I want ... but there are numerous ways to accomplish it.  I want suggestions on what&#39;s most likely to work for other users of the code in the long run.

The code itself is at: [classh](http://bitbucket.org/jimd/classh).




Python Observer Pattern: Examples, Tips?

I am using [`Transformations.switchMap`](https://developer.android.com/reference/android/arch/lifecycle/Transformations.html) in my ViewModel so my `LiveData` collection, observed in my fragment, reacts on changes of `code` parameter.

This works perfectly :

    public class MyViewModel extends AndroidViewModel {
    
        private final LiveData&lt;DayPrices&gt; dayPrices;
        private final MutableLiveData&lt;String&gt; code = new MutableLiveData&lt;&gt;();
        // private final MutableLiveData&lt;Integer&gt; nbDays = new MutableLiveData&lt;&gt;();
        private final DBManager dbManager;
    
        public MyViewModel(Application application) {
            super(application);
            dbManager = new DBManager(application.getApplicationContext());
            dayPrices = Transformations.switchMap(
                code,
                value -&gt; dbManager.getDayPriceData(value/*, nbDays*/)
            );
        }
    
        public LiveData&lt;DayPrices&gt; getDayPrices() {
            return dayPrices;
        }
    
        public void setCode(String code) {
            this.code.setValue(code);
        }

        /*public void setNbDays(int nbDays) {
            this.nbDays.setValue(nbDays);
        }*/
    
    }

    public class MyFragment extends Fragment {

        private MyViewModel myViewModel;

        myViewModel = ViewModelProviders.of(this).get(MyViewModel.class);
        myViewModel.setCode(&quot;SO&quot;);
        //myViewModel.setNbDays(30);
        myViewModel.getDayPrices().observe(MyFragment.this, dataList -&gt; {
            // update UI with data from dataList
        });
    }

**Problem**

I now need another parameter (`nbDays` commented in the code above), so that my `LiveData` object reacts on both parameters change (`code` and `nbDays`).

How can I chain transformations ?

Some reading pointed me to [MediatorLiveData](https://developer.android.com/reference/android/arch/lifecycle/MediatorLiveData.html), but it does not solve my problem (still need to call single DB function with 2 parameters, I don&#39;t need to merge 2 liveDatas).

So I tried this instead of `switchMap` but `code` and `nbDays` are always null.

    dayPrices.addSource(
        dbManager.getDayPriceData(code.getValue(), nbDays.getValue),
        apiResponse -&gt; dayPrices.setValue(apiResponse)
    );

One solution would be to pass an object as single parameter by I&#39;m pretty sure there is a simple solution to this.

MediatorLiveData or switchMap transformation with multiple parameters

I am trying to implement something like a delegation pattern in Angular. 
When the user clicks on a `nav-item`, I would like to call a function which then emits an event which should in turn be handled by some other component listening for the event.

Here is the scenario: I have a `Navigation` component:

&lt;!-- language-all: lang-ts --&gt;

    import {Component, Output, EventEmitter} from &#39;angular2/core&#39;;
    
    @Component({
        // other properties left out for brevity
    	events : [&#39;navchange&#39;], 
        template:`
          &lt;div class=&quot;nav-item&quot; (click)=&quot;selectedNavItem(1)&quot;&gt;&lt;/div&gt;
        `
    })
    
    export class Navigation {
    
    	@Output() navchange: EventEmitter&lt;number&gt; = new EventEmitter();
    
    	selectedNavItem(item: number) {
    		console.log(&#39;selected nav item &#39; + item);
    		this.navchange.emit(item)
    	}
    
    }

Here is the observing component: 

    export class ObservingComponent {
    
      // How do I observe the event ? 
      // &lt;----------Observe/Register Event ?--------&gt;
     
      public selectedNavItem(item: number) {
        console.log(&#39;item index changed!&#39;);
      }
    
    }

The key question is, how do I make the observing component observe the event in question ? 

Delegation: EventEmitter or Observable in Angular

An interviewer asked me:

*What is `Observer` and `Observable` and when should we use them?*

I wasn&#39;t aware of these terms, so when I got back home and started Googling about `Observer` and `Observable`, I found some points from different resources:

&gt; 1) [`Observable`](https://docs.oracle.com/javase/8/docs/api/java/util/Observable.html) is a class and [`Observer`](https://docs.oracle.com/javase/8/docs/api/java/util/Observer.html) is an interface.
&gt; 
&gt; 2) The `Observable` class maintains a list of `Observer`s.
&gt; 
&gt; 3) When an `Observable` object is updated, it invokes the `update()` method of each of its `Observer`s to notify that, it is changed.

I found this example:

    import java.util.Observable;
    import java.util.Observer;
    
    class MessageBoard extends Observable
    {
        public void changeMessage(String message) 
        {
            setChanged();
            notifyObservers(message);
        }
    }
    
    class Student implements Observer 
    {
        @Override
        public void update(Observable o, Object arg) 
        {
            System.out.println(&quot;Message board changed: &quot; + arg);
        }
    }
    
    public class MessageBoardTest 
    {
        public static void main(String[] args) 
        {
            MessageBoard board = new MessageBoard();
            Student bob = new Student();
            Student joe = new Student();
            board.addObserver(bob);
            board.addObserver(joe);
            board.changeMessage(&quot;More Homework!&quot;);
        }
    }


But I don&#39;t understand why we need `Observer` and `Observable`? What are the `setChanged()` and `notifyObservers(message)` methods for?



When should we use Observer and Observable?

I&#39;m setting up an after_save callback in my model observer to send a notification only if the model&#39;s *published* attribute was changed from false to true. Since methods such as *changed?* are only useful before the model is saved, the way I&#39;m currently (and unsuccessfully) trying to do so is as follows:

    def before_save(blog)
      @og_published = blog.published?
    end
    
    def after_save(blog)
      if @og_published == false and blog.published? == true
        Notification.send(...)
      end
    end

Does anyone have any suggestions as to the best way to handle this, preferably using model observer callbacks (so as not to pollute my controller code)?

Determine what attributes were changed in Rails after_save callback?

What is the difference between the **[Observer Pattern][1]**, **[Publish/Subscribe][2]**, and **[Data Binding][3]**?

I searched around a bit on Stack Overflow and did not find any good answers.

What I have come to believe is that data binding is a generic term and there are different ways of implementing it such as the Observer Pattern or the Pub/Sub pattern. With the Observer pattern, an Observable updates its Observers.  With Pub/Sub, 0-many publishers can publish messages of certain classes and 0-many subscribers can subscribe to messages of certain classes.

**Are there other patterns of implementing &quot;data binding&quot;?**

  [1]: http://en.wikipedia.org/wiki/Observer_pattern
  [2]: http://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern
  [3]: http://en.wikipedia.org/wiki/UI_data_binding

Difference between Observer, Pub/Sub, and Data Binding

Java 9 came out, and [`Observer`](https://docs.oracle.com/javase/9/docs/api/java/util/Observer.html) has been deprecated.
Why is that? Does it mean that we shouldn&#39;t implement observer pattern anymore? 

It would be good to know what is a better alternative?

Observer is deprecated in Java 9. What should we use instead of it?

It seems to me that the Observer design pattern as described in GOF is really the same thing as Listeners found in various toolkits. Is there a difference between the concepts, or are Listeners and Observers really the same thing. 

(I&#39;m not looking for any specific computer language implementation, I just want to understand the difference (if any) from a design point of view. Yes, I know there are several answers to similar questions on SOF, but they&#39;re rooted in specific questions about specific languages -- I&#39;m looking for a design answer, not a language answer.)

Observer Design Pattern vs &quot;Listeners&quot;

I recently started digging into C# but I can&#39;t by my life figure out how delegates work when implementing the observer/observable pattern in the language.

Could someone give me a super-simple example of how it is done? I *have* googled this, but all of the examples I found were either too problem-specific or too &quot;bloated&quot;.

Super-simple example of C# observer/observable with delegates

I have been reading the **[Gang Of Four][1]**, in order to solve some of my problems and came across the **Mediator** pattern.

I had earlier used **Observer** in my projects for making some GUI application. I am a bit confused as I do not find great difference between the two. I browsed to find the difference but could not find any apt answer for my query.

Could some one help me to differentiate between the two with some good example which clearly demarcates the two?

  [1]: https://en.wikipedia.org/wiki/Design_Patterns

Mediator Vs Observer Object-Oriented Design Patterns

I realise this question has to do with event-handling and i&#39;ve read about Python event-handler a dispatchers, so either it did not answer my question or i completely missed out the information.

I want method `m()` of object `A` to be triggered whenever value `v` is changing: 

For instance (assuming money makes happy):
    
    global_wealth = 0
     
    class Person()
        def __init__(self):
            self.wealth = 0
            global global_wealth
            # here is where attribute should be
            # bound to changes in &#39;global_wealth&#39;
            self.happiness = bind_to(global_wealth, how_happy)
        
        def how_happy(self, global_wealth):
            return self.wealth / global_wealth

So whenever the `global_wealth` value is changed, all instances of the class `Person` should change their `happiness` value accordingly.

***NB:** I had to edit the question since the first version seemed to suggest i needed getter and setter methods. Sorry for the confusion.*

How to trigger function on value change?

I always found the Observer Pattern almost similar to the usual event-driven approach. Actually, I have almost believed that they are actually just different names referring to the same thing. They both use similar concepts to have something as a listener and even in the implementation, they are almost the same thing, that&#39;s to have a callback method/function to carry out an action. This is at least in Java.

In other languages say Actionscript/Flex, the events are more user-friendly and may look like it does more than just the observer pattern defines. But still, the concepts sound the same.

But is this really true? Is the Observer Pattern the same thing as the usual event-driven programming style?

Difference between Observer Pattern and Event-Driven Approach

What are the pros and cons of keeping listeners as WeakReferences?

The big &#39;Pro&#39; of course is that:

Adding a listener as a WeakReference means the listener doesn&#39;t need to bother &#39;removing&#39; itself.

For those worried about the listener having the only reference to the object, why can&#39;t there be 2 methods, addListener() and addWeakRefListener()? 

Those who don&#39;t care about removal can use the latter.

Pros and Cons of Listeners as WeakReferences

Recently I heard the term *reactive programming* a lot, but when I searched for it, what I discovered was only some similarities with *observer pattern*. Actually, I cannot find any differences between them. What&#39;s conceptual difference between them and why the term *reactive programming* is getting buzzed?

What is difference between observer pattern and reactive programming?

I&#39;ve got the following (simplified):

    interface IFindFilesObserver
    {
        void OnFoundFile(FileInfo fileInfo);
        void OnFoundDirectory(DirectoryInfo directoryInfo);
    }

    class FindFiles
    {
        IFindFilesObserver _observer;

        // ...
    }

...and I&#39;m conflicted. This is basically what I would have written in C++, but C# has events. Should I change the code to use events, or should I leave it alone?

What are the advantages or disadvantages of events over a traditional observer interface?


C#: events or an observer interface? Pros/cons?

I have an observer and I register an `after_commit` callback.
How can I tell  whether it was fired after create or update?
I can tell an item was destroyed by asking `item.destroyed?` but `#new_record?` doesn&#39;t work since the item was saved.

I was going to solve it by adding `after_create`/`after_update` and do something like `@action = :create` inside and check the `@action` at `after_commit`, but it seems that the observer instance is a singleton and I might just override a value before it gets to the `after_commit`. So I solved it in an uglier way, storing the action in a map based on the item.id on after_create/update and checking its value on after_commit. Really ugly.

Is there any other way?

# Update

As @tardate said, `transaction_include_action?` is a good indication, though it&#39;s a private method, and in an observer it should be accessed with `#send`.

    class ProductScoreObserver &lt; ActiveRecord::Observer
      observe :product

      def after_commit(product)
        if product.send(:transaction_include_action?, :destroy)
          ...

Unfortunately, the `:on` option does not work in observers.

Just make sure you test the hell of your observers (look for `test_after_commit` gem if you use use_transactional_fixtures) so when you upgrade to new Rails version you&#39;ll know if it still works.

(Tested on 3.2.9)

# Update 2

Instead of Observers I now use ActiveSupport::Concern and `after_commit :blah, on: :create` works there.

Rails 3: How to identify after_commit action in observers? (create/update/destroy)

I was reading some article to understand a little bit more how AngularJS works.

One of the terms that I didn&#39;t understand is `Dirty Checking`. 

What is it exactly? It seems like the Observer pattern but apparently it&#39;s better.

Can you help me understand this please?

EDIT : it can be also useful for people who wants to learn more about that to watch [this video]( https://www.youtube.com/watch?v=Mk2WwSxK218 ) from [swiip](https://github.com/Swiip) at NgEurope some years ago.

All Observer Pattern Solutions on Gang of Coders

Total of 18 Observer Pattern Solutions