Functional Reactive Programming (FRP) is a specific programming model with a specific semantics.
(Actually, there are two variants, which are sometimes called &quot;classic FRP&quot; and &quot;arrow FRP&quot;.)
I&#39;ve given a summary in [an answer to &quot;What is (functional) reactive programming?&quot;](https://stackoverflow.com/questions/1028250/what-is-functional-reactive-programming/1030631#1030631).
As I said there, the two key properties for me have always been (a) precise &amp; simple denotation and (b) continuous time.
I regret that this model came to be called &quot;functional reactive programming&quot;, for a few reasons:

* That name omits &quot;time&quot;, and time is central for me.
* The term &quot;functional&quot; has so little specific/clear meaning.
  I much prefer Peter Landin&#39;s suggested replacement &quot;denotative&quot;.
  (See the quotes and reference in [this blog comment](http://conal.net/blog/posts/is-haskell-a-purely-functional-language/#comment-35882).)
* It&#39;s easy for people to incorrectly think they know what the term means because they know meanings (more or less) of each of the three words.

For descriptiveness &amp; accuracy, I prefer the term &quot;denotative continuous-time programming&quot; (suggested by Jake McArthur in a conversation a while back) over &quot;functional reactive programming&quot;.

I wrote a very short piece on the origin of FRP in the blog post [*Early inspirations and new directions in functional reactive programming*](http://conal.net/blog/posts/early-inspirations-and-new-directions-in-functional-reactive-programming/).


FRP is a combination of Functional programming(programming paradigm built upon the idea of everything is a pure function) and reactive programming paradigm (built upon the idea that everything is a stream(observer and observable philosophy)). It is suppose to be the best of both the worlds.

The definition of both give a more clear distinction between the two.

I want to get the domain name for where the script is running. How can that be done with PHP?
I see that `$_SERVER[&#39;HTTP_HOST&#39;]` as well as `$_SERVER[&#39;SERVER_NAME&#39;]` contain this information.
Will that variable always work and should I use one over the other?

Thank you.

PHP get domain name

If I want the number of items in an iterable without caring about the elements themselves, what would be the pythonic way to get that? Right now, I would define

    def ilen(it):
        return sum(itertools.imap(lambda _: 1, it))    # or just map in Python 3

but I understand `lambda` is close to being considered harmful, and `lambda _: 1` certainly isn&#39;t pretty.

(The use case of this is counting the number of lines in a text file matching a regex, i.e. `grep -c`.)

What&#39;s the shortest way to count the number of items in a generator/iterator?

I have been doing some research into reactive programming recently and I&#39;m finding it hard to find a good description of the difference between Reactive and **Functional**-Reactive. 

Is it simply that the reactive programming is implemented using functional methods/paradigms as opposed to using declarative or OO paradigms? 

The difference between Reactive and Functional-Reactive programming

I have been doing some research into reactive programming recently and I'm finding it hard to find a good description of the difference between Reactive and Functional-Reactive.
Is it simply that the reactive programming is implemented using functional methods/paradigms as opposed to using declarative or OO paradigms?

so when you initialize an array, you can assign multiple values to it in one spot:

    int array [] = {1,3,34,5,6}

but what if the array is already initialized and I want to completely replace the values of the elements in that array in one line

so 

    int array [] = {1,3,34,5,6}
    array [] = {34,2,4,5,6}

doesn&#39;t seem to work...

is there a way to do so?

c++ array assignment of multiple values

I am looking at messing around with creating a functional reactive framework at some point. I have read quite a lot about it and seen a few examples but I wanted to get a clear idea of what this framework would HAVE to do to be considered an FRP extension/dsl. I&#39;m not really concerned with implementation problems or specifics etc but more as to what would be desired in a perfect world situation.

What would be the key operations and qualities of an ideal functional reactive programming language?

Specification for a Functional Reactive Programming language

A [recent blog post on William Cook&#39;s Fusings](http://wcook.blogspot.com/) mentions:

&gt; The key point is that structures in Ensō are viewed holistically as graphs, not as individual values or traditional sums-and-products data structures.

What are the traditional sums-and-products data structures he is referring to?

What are &quot;sums-and-products&quot; data structures?

I have been programming for some months now and a frequently used word is &quot;context&quot; in classes. Like `ServletContext` (Java), `Activity` (Android), `Service` (Java, Android), `NSManagedContext` (Objective-C, iOS).

By looking in dictionaries I see that the word means: situation, environment, circumstances etc. However, because I am not a native English speaker I do not understand what I should translate it directly to. For instance, if I were to write a class that either was named `SomeClassContext`, or a method that had a context parameter, I would not understand when I should name it context because I do not understand it.

I have been searching for context on Stack Overflow, but no question/answers was able to help me.

I would be very happy if someone could provide me with the explanation.

The term &quot;Context&quot; in programming?

I want to start an activity in my `onReceive()` method.

    package com.splashscreenactivity;

    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.os.Bundle;
    import android.telephony.SmsMessage;
    import android.widget.Toast;

    public class SMSReceiver extends BroadcastReceiver {

    	public static String trigger_message = &quot;&quot;;

    	@Override
    	public void onReceive(Context context, Intent intent) {
    		// ---get the SMS message passed in---
    		Bundle bundle = intent.getExtras();
    		SmsMessage[] msgs = null;
    		String str = &quot;&quot;;
    		if (bundle != null) {
    			// ---retrieve the SMS message received---
    			Object[] pdus = (Object[]) bundle.get(&quot;pdus&quot;);
    			msgs = new SmsMessage[pdus.length];
    			for (int i = 0; i &lt; msgs.length; i++) {
    				msgs[i] = SmsMessage.createFromPdu((byte[]) pdus[i]);
    				str += &quot;SMS from &quot; + msgs[i].getOriginatingAddress();
    				str += &quot; :&quot;;
    				trigger_message = msgs[i].getMessageBody().toString();
    				str += trigger_message;
    				str += &quot;\n&quot;;
    			}
    			// ---display the new SMS message---
    			Toast.makeText(context, str, Toast.LENGTH_SHORT).show();
    			if (trigger_message.equals(&quot;dx&quot;)) {
    				Toast.makeText(context, &quot;I am triggered&quot;, Toast.LENGTH_LONG)
    						.show();
    				// /////////////////////////
    				// i want to start here
    				// ////////////////////////
    				// MainScreenActivity.trigger=&quot;Now&quot;;
    				// Intent i = new Intent(context,GPS.class);
    				// i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    				// context.startActivity(i);
    			} else {
    				Toast.makeText(context, &quot;I am not triggered,  Bbyz!!!&quot;,
    						Toast.LENGTH_LONG).show();
    			}
    		}
    	}
    }



here is GPS.class

    package com.splashscreenactivity;

    import android.app.Activity;
    import android.content.BroadcastReceiver;
    import android.content.Context;
    import android.content.Intent;
    import android.location.Location;
    import android.location.LocationListener;
    import android.location.LocationManager;
    import android.os.Bundle;
    import android.telephony.SmsManager;
    import android.telephony.SmsMessage;
    import android.widget.TextView;
    import android.widget.Toast;

    public class GPS extends Activity implements LocationListener {

    	TextView latitude, logitude;

    	/** Called when the activity is first created. */
    	@Override
    	public void onCreate(Bundle savedInstanceState) {
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.gps);
    		LocationManager lm = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
    		lm.requestLocationUpdates(LocationManager.GPS_PROVIDER, 1000L, 500.0f,
    				this);
    		Toast.makeText(this, &quot;i m started&quot;, Toast.LENGTH_LONG);
    		// latitude = (TextView)findViewById(R.id.txtLat);
    		// logitude = (TextView)findViewById(R.id.txtLongi);
    		// latitude.setText(&quot;Loading...&quot;);
    		// logitude.setText(&quot;Loading...&quot;);
    	}

    	String LATTITUDE;
    	String LOGITUDE;

    	@Override
    	public void onLocationChanged(Location location) {
    		double lat = location.getLatitude();
    		double lag = location.getLongitude();
    		LATTITUDE = Double.toString(lat);
    		LOGITUDE = Double.toString(lag);
    		// latitude.setText(LATTITUDE);
    		// logitude.setText(LOGITUDE);
    		// SmsManager sm = SmsManager.getDefault();
    		// // here is where the destination of the text should go
    		// String number = &quot;5556&quot;;
    		// sm.sendTextMessage(number, null,
    		// &quot;latitude=&quot;+latitude.getText()+&quot;\nlongitude=&quot;+logitude.getText(),
    		// null, null);
    	}

    	@Override
    	public void onProviderDisabled(String arg0) {
    	}

    	@Override
    	public void onProviderEnabled(String arg0) {
    	}

    	@Override
    	public void onStatusChanged(String arg0, int arg1, Bundle arg2) {
    	}
    	// /** Register for the updates when Activity is in foreground */
    	// @Override
    	// protected void onResume()
    	// {
    	// super.onResume();
    	// lm.requestLocationUpdates(LocationManager.GPS_PROVIDER, 1000L, 500.0f,
    	// this);
    	// }
    	//
    	// /** Stop the updates when Activity is paused */
    	// @Override
    	// protected void onPause() {
    	// super.onPause();
    	// lm.removeUpdates(this);
    	// }
    }


Start Activity inside onReceive BroadcastReceiver

I wish to throw an exception and have the following:

    (throw &quot;Some text&quot;)

However it seems to be ignored.

How can I throw an exception in Clojure?

I know that in some languages (Haskell?) the striving is to achieve point-free style, or to never explicitly refer to function arguments by name.  This is a very difficult concept for me to master, but it might help me to understand what the advantages (or maybe even disadvantages) of that style are.  Can anyone explain?

What are advantages and disadvantages of &quot;point free&quot; style in functional programming?

Say I want to sum `a.x` for each element in `arr`.

```js
arr = [ { x: 1 }, { x: 2 }, { x: 4 } ];
arr.reduce(function(a, b){ return a.x + b.x; }); // =&gt; NaN
```

I have cause to believe that `a.x` is `undefined` at some point.

The following works fine

```js
arr = [ 1, 2, 4 ];
arr.reduce(function(a, b){ return a + b; }); // =&gt; 7
```

What am I doing wrong in the first example?

How to call reduce on an array of objects to sum their properties?

I have twice recently refactored code in order to change the order of parameters because there was too much code where hacks like `flip` or `\x -&gt; foo bar x 42` were happening.

When designing a function signature what principles will help me to make the best use of currying? 

Ordering of parameters to make use of currying

I&#39;m trying to visualize some simple automatic physical systems (such things as pendulum, robot arms,etc.) in Haskell.
Often those systems can be described by equations like

`df/dt = c*f(t) + u(t)`

where `u(t)` represents some kind of &#39;intelligent control&#39;. Those systems look to fit very nicely in the Functional Reactive Programming paradigm.

So I grabbed the book &quot;The Haskell School of Expression&quot; by Paul Hudak,
and found that the domain specific language &quot;FAL&quot; (for Functional Animation Language) presented there actually works quite pleasently for my simple toy systems (although some functions, notably `integrate`, seemed to be  a bit too lazy for an efficient use, but easily fixable).

My question is, what&#39;s the more mature, up-to-date, well-maintained, performance-tuned alternative for more advanced, or even practical applications today?

[This wiki page](http://www.haskell.org/haskellwiki/Functional_Reactive_Programming) lists several options for Haskell, but I&#39;m not clear about the following respects:

1. The status of &quot;reactive&quot;, the project from Conal Eliott who is (as I understand it) one of the inventers of this programming paradigm, looks a bit stale. I love his code, but maybe I should try other more up-to-date alternatives? What&#39;s the primary difference between them, in terms of syntax/performance/runtime-stability?

2. To quote from a [survey](http://www.cs.rit.edu/~eca7215/frp-independent-study/Survey.pdf) in 2011, Section 6, &quot;_... FRP implementations are still not efficient enough or predictable enough in performance to be used effectively in domains which require latency guarantees ..._&quot;. Alghough the survey suggests some interesting possible optimizations, given the fact that FRP is there for more than 15 years, I get the impression that this performance problem might be something _very_ or even inherently difficult to solve at least within a few years. Is this true?

3. The same author of the survey talks about &quot;time leaks&quot; in his [blog](http://blog.edwardamsden.com/2011/03/demonstrating-time-leak-in-arrowized.html). Is the problem unique to FRP, or something we are generally having when programming in a pure, non-strict language? Have you ever found it just too difficult to stabilize an FRP-based system over time, if not performant enough?

4. Is this still a research level project? Are the people like plant engineers, robotics engineers, financial engineers, etc. actually using them (in whaterver language that suits their needs)?

Although I personally prefer a Haskell implementation, I&#39;m open to other suggestions. For example, it would be particularly fun to have an Erlang implementation --- it would then be very easy to have an intelligent, adaptive, self-learning server process!


What&#39;s the status of current Functional Reactive Programming implementations?

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 seem to be a little bit confused when comparing Clojure&#39;s **core.async** to the so called **Reactive Extensions** (Rx) and **FRP** in general. They seem to tackle similar problem of async-hronicity, so I wonder what are the principal differences and in what cases is one preferred over the other. Can someone please explain?

EDIT: To encourage more in-depth answers I want to make the question more specific:

1. Core.async allows me to write synchronous-looking code. However as I understand it FRP only needs one level of nested callbacks (all the function that handle logic are passed as arguments to FRP API). This seems that both approaches make the callback *pyramids* unnecessary. It is true that in JS I have to write `function() {...}` many times, but the main problem, the *nested* callbacks, is gone in FRP also. Do I get it right?

2. &quot;**FRP** complects the communication of messages with flow of control&quot; Can you (someone) please give a more specific explanation?

3. Can&#39;t I pass around FRP&#39;s observable endpoints the same way as i pass channels?

In general I understand where both approaches historically come from and I have tried few tutorials in both of them. However I seem to be &quot;paralyzed&quot; by the non-obviousness of differences. Is there some **example of a code that would be hard to write in one of these and easy using the other**? And what is the architectural reason of that?

Comparing core.async and Functional Reactive Programming (+Rx)

Can someone give a clear definition together with a simple example that explains what is a &quot;callback hell&quot; for someone who does not know JavaScript and node.js ?

When (in what kind of settings) does the &quot;callback hell problem&quot; occur? 

Why does it occur?

Is &quot;callback hell&quot; always related to asynchronous computations? 

Or can &quot;callback hell&quot; occur also in a single threaded application? 

I took the Reactive Course at Coursera and Erik Meijer said in one of his lectures that RX solves the problem of &quot;callback hell&quot;. I asked what is a &quot;callback hell&quot; on the Coursera forum but I got no clear answer.  

After explaining &quot;callback hell&quot; on a simple example, could you also show how RX solves the &quot;callback hell problem&quot; on that simple example?

What is &quot;callback hell&quot; and how and why does RX solve it?

Recently I&#39;ve started looking at &lt;a href=&quot;https://github.com/Reactive-Extensions/RxJS&quot;&gt;RxJS&lt;/a&gt; and RxJava(from Netflix) libraries which work on the concept of Reactive Programming. 

Node.js works on the basis of event loops, which provides you all the arsenal for asynchronous programming and the subsequent node libraries like &quot;cluster&quot; help you to get best out of your multi-core machine. And Node.js also provides you the EventEmitter functionality where you can subscribe to events and act upon it asynchronously. 

On the other hand if I understand correctly RxJS (and Reactive Programming in general) works on the principle of event streams, subscribing to event streams, transforming the event stream data asynchronously. 

So, the question is what does using Rx packages in Node.js mean. How different is the Node&#39;s event loop, event emitter &amp; subscriptions to the Rx&#39;s streams and subscriptions.

Content Type	Original Author	Original Content on Stackoverflow
Question	seadowg	View Question on Stackoverflow
Solution 1 - Programming Languages	Conal	View Answer on Stackoverflow
Solution 2 - Programming Languages	Krishna Ganeriwal	View Answer on Stackoverflow

The difference between Reactive and Functional-Reactive programming

Programming Languages Problem Overview

Programming Languages Solutions

Solution 1 - Programming Languages

Solution 2 - Programming Languages

What's the shortest way to count the number of items in a generator/iterator?

PHP get domain name

Attributions