Slashdot Mirror
How Reactive Programming Differs From Procedural Programming
Nerval's Lobster writes "A recent post on Reactive Programming triggered discussions about what is and isn't considered Reactive Logic. In fact, many have already discovered that Reactive Programming can help improve quality and transparency, reduce programming time and decrease maintenance. But for others, it raises questions like: How does Reactive differ from conventional event-oriented programming? Isn't Reactive just another form of triggers? What kind of an improvement in coding can you expect using Reactive and why? So to help clear things up, columnist and Espresso Logic CTO Val Huber offers a real-life example that he claims will show the power and long-term advantages Reactive offers. 'In this scenario, we'll compare what it takes to implement business logic using Reactive Programming versus two different conventional procedural Programming models: Java with Hibernate and MySQL triggers,' he writes. 'In conclusion, Reactive appears to be a very promising technology for reducing delivery times, while improving system quality. And no doubt this discussion may raise other questions on extensibility and performance for Reactive Programming.' Do you agree?"
not re-active! ;-)
Paul B.
There really is no such thing, they just made up the term for attention. What he is describing might be called "tools" programming, but it's not new or different. I have written "Tools" in various languages for over 20 years. If they think they are going to market a few bucks with a "re-branding" program good for them. It worked for "Cloud" and I knew better then too.
-The wise argue that there are few absolutes, the fool argues that there are no probabilities.
Hello, Paul. How are we doing this evening? ;)
How does RP handle dupes?
I know I put in my $0.02 previously, so I won't bother again.
For all intensive purposes, "whom" is no longer a word. That begs the question, "who cares"?
1) The proactive, forward looking teams adopt it first, and have great success.
2) The "emerging trend followers" hop on board, and have reasonable results.
3) The rest of the industry follow and have mixed results, without it being any more successful than any other methodology.
Don't be blinded - initial results always look very promising.
Anybody around here remember Jackson Structured Programming The initial OOP wave? The whole CASE moevement? GUI application builders that were supposed to end the need for programmers?
The golden rule is that "whatever methodology technology you choose, half of adopters will always get sub-average results". The question you have to ask yourself Is are your team smarter than the average team?
Yet another super awesome framework/system/language/whatever to make a shopping cart in as few lines as possible.
The someone tries to build something remotely complex and it all falls to shit and the code ends up as spaghetti.
The guy who built it then leaves the company and they can't find anyone else with the skills to understand how it works
Point proven.
Sig Battery depleted. Reverting to safe mode.
Buzz words! Get your red hot buzzwords! These buzzwords are fresh folks! No one's even figured out what they mean yet! You snooze, you lose! You there, little boy, I bet you could use Web 3.0!
The world's burning. Moped Jesus spotted on I50. Details at 11.
Isn't reactive programming essentially a repackaging of Table Oriented Programming?
"First they came for the slanderers and i said nothing."
this is just rebadged functional programming, except using deliberately confusing syntax
Snowden and Manning are heroes.
This article summary ends "And no doubt this discussion may raise other questions on extensibility and performance for Reactive Programming.' Do you agree?""
But a superior ending would be "Don't you agree?"
Because any response to "Don't you agree?" is better for marketing FUD because any potential answer ("Yes", "No") can be interpreted with being in agreement with the leading question?
(This comment is revelvant specifically because the term is "Reactive programming" is a worthless marketing buzzword and I am staying on-topic discussing how to improve superior ambiguity. And I can argue it is revelvant because "revelvant" is not a word and can have any retroactive intended meaning! So double the value of this post in the marketing department!)
Priest: "Universe from nothing, no laws of physics, sped up time"+ huge discrepancies. Creationism? No. Big Bang Theory
yeah...see this is true, and my question is WHY?
this happens predictably (at least for any rational person who looks at how this part of the computing industry changes over time)
but still people spend good time/money, sometimes lots of a few people's time, to make another and the cycle starts over again
is it possible to interview for a company, or be the head 'coder' during a major decision time for a new client or product, and just say, "No, from a coding perspective this is theoretically possible but it can't be done. This is bad design and we can code something that has this function and meet our quality standards."
can that happen?
Thank you Dave Raggett
Articles like this really annoy me. There are so many things wrong, it's hard to decide where to start. He concludes in favour of reactive by comparing java and mysql complete with all white space, comments and declarations, with a few bullet pointed reactive expressions in order to fluff up the numbers as much as possible. He makes no attempt to give a balanced viewpoint and makes conclusions based on false statistics and insignificant results. I've seen many so-called experts write junk like this to promote whatever their shiny new API is over the years. Most of them have ended up in limited edge systems, maintained by developers who would rather be doing anything than dealing with the nightmare.
Reactive might be a good idea, but I'm tired of dealing with people sucked in by junk science like this.
For example, the "Purchase Order" entity includes a reference to a sales rep. From it's inclusion we infer that is important data, so it would also need to be added as a "reaction". There's also no hint on how these "reactions" are actually implemented. The original article claims that consistency is enforced but doesn't really explain why.
The above might be what they mean, but that's not sufficient for consistency. If your database field is merely a duplicate of derived data in other entities, you shouldn't pat yourself on the back for avoiding a problem you created in the first place! You can also overlook a use case in the analysis phase too, and then you'll fail to include it regardless of the framework.
I think I'd like to see an example with all the entities included and some normalisation. Then maybe I might be convinced that RP has any advantages over triggers.
Plan My Week for iPhone
See JBoss Drools, JRules, Blaze, etc.
We used to make websites by regenerate all html pages when the database changes. It delivers really fast then.
Yeah, that's "reactive programming" at the file level. I do it all the time, with Makefiles. Lots of people do. A nice thing about a Makefile is that you can easily control when the calculation of derivative files happens. You (re)create some sets of primary data, then use a simple "make" command to rebuild everything that depends on any of them.
This is yet another illustration that the perps who introduced this supposedly-new concept have mostly just found a new buzzword for an approach that has been reinvented repeatedly in the past.
One of the ongoing problems in many fields of science and technology is the constant rediscovery (or reinvention if you prefer) of concepts long known by others that just use different words for the concepts.
Actually, mathematicians long ago realized this, and have a standard term for things that are described differently but are actually identical: They're generally called "isomorphic". A classical example that's important in computers was George Boole's "Boolean algebra", invented primarily as an exercise in pure logic. Eventually people noticed that it was isomorphic to the "propositional calculus", and then as electricity became widely available, engineers found that their new "circuit switching calculus" was another isomorphism. That's why so many programming languages have those AND, OR, XOR, NOT, etc operators.
This crowd is merely giving us another entry in the rather long list of isomorphic systems that differ only in their terminology. This means time wasted re-developing your system from scratch, when you could have saved a lot of time if you'd only realized that others had already solved your problem for you. But we don't have a good way to discover that two systems described with different words really are the same thing.
(Or do we? Maybe some mathematical linguists are working on the problem right now, and we don't realize this because we don't recognize their terminology.)
Those who do study history are doomed to stand helplessly by while everyone else repeats it.
This is nothing new. You can wrap up the complexity of the code in a toolkit/framework/library but this is just functional programming driven by events. Nothing to see here. Move along. Don't believe the hype.
"As flies to the wanton boys are we to the gods; they kill us for sport." - William Shakespeare, King Lear
from what i've read on wikipedia, "Reactive Programming" is really just function as a variable with caching.
example:
c = 5 // outputs 9 // outputs 10
b = 4
a = b + c
print(a)
c = 6
print(a)
this isnt rocket surgery
Anons need not reply. Questions end with a question mark.
Their presentation makes analogies between "reactive programming" and spreadsheets and specifically references the power of "chaining" to have multiple functions firing as the result of changes.
There are a number of issues with this kind of event chaining that you run into as you get past the toy cases.
1) Fan-out. How many actions are being kicked off by a simple change?
2) Latency - this is a direct corollary to the fanout. Are all of the chained functions being run synchronously? If so, what happens when someone introduces a very slow function that gets run as the result of a user input. So the user changes the price of a part and every purchase order in the system is suddenly being updated?
3) Synchronicity - of course, as soon as you find out that your synchronously run chained functions slow things down you start running them in the background. Now, you have a problem where you don't know if something is up-to-date or not. And, in this model, it's not possible to find out if something is up-to-date.
The examples that they gave are very poor use cases for triggers even. Most general ledger systems I've looked at, running on top of a database, would just recalculate the balance on demand. If your database is large enough that the recalculation starts to take significant time, you cache the result and invalidate it using a trigger. Most GL systems typically make entries much more frequently than they need to calculate the balance for an account. If the recalculation of the balance takes significant time, you probably don't want to do it every time an entry is made anyhow.
Stored procedures and triggers are already here and I see no evidence that there is anything new here. If the database is in a correct normalized form this will not reduce the amount of code one iota.
Do ***NOT*** put this sort of logic in the application code. Use properly written stored procedures, foreign key constraints, and database triggers and don't let "application" programmers (especially not agile ones or those who invent new terminology for well known and previously solved problems) within 100 miles of the logic.
And as far as the users being able to understand it "better" I have only one word to say: Bwahahahahahahahahahaha!
Given how much anti-education rhetoric combined with fads and agism I see in technology, it seems like tech is worse then most fields about reinventing the past. There seems to be an almost pathological desire to not acknowledge when something is a revisit of an older idea. Maybe too much ego wrapped up in being original?
Yeah, that's "reactive programming" at the file level. I do it all the time, with Makefiles. Lots of people do. A nice thing about a Makefile is that you can easily control when the calculation of derivative files happens. You (re)create some sets of primary data, then use a simple "make" command to rebuild everything that depends on any of them.
But that isn't reactive; it's still polling.
Reactive is the opposite of polling. E.g. if you wanted Makefiles to be reactive, your filesystem would need to notify when a change occurs, and then that change would immediately cause a compile (or whatever it is in your data calculation case) of only the pieces that are directly affected by that, and so on up the chain until the final result is produced.
If you have to type "make [...]" or set up a cron job, you aren't doing reactive.
All my liberal friends think I'm a conservative, all my conservative friends think I'm a liberal.
You've hit it exactly - they've "invented" Makefiles for database rows.
In a sense, that didn't exist before, so that's something new, and it's definitely simpler than writing the 200 lines of code to do what make would automatically do for you.
I'm not sold on it taking over the world, but it's an interesting application of the idea.
(Well, actually, it did exist before - they point out the example of a spreadsheet, which does exactly what they're talking about. This seems to be the answer to "why can't we program databases the same way we do spreadsheets and Makefiles?")
"Go to CNN [for a] spell-checked, fact-checked summary" -- CmdrTaco
I've been looking at ways to make CRUD applications "declarative" using almost nothing but data dictionaries (field tables) and attributes. It can be done for relatively simple and controlled scenarios, but if you have unanticipated requirements or are stuck using an existing database that has built up years of baggage/cruft, then it requires custom interventions.
CRUD is conceptually relatively simple, but the devil's in the details and those details can really be devils.
Yes, you can simplify CRUD by making certain presumptions. However, if you have to violate those presumptions, then your clean abstractions take a big hit to the nuts and the fixes are messier than what you'd get hand coding most of it from scratch or from minimalist libraries.
That appears to be "trick" used here: when your scenario lines up nicely with your framework's assumptions, the framework handles most of the grunt work like magic. It's essentially a circus trick for the naive.
Until the day CRUD is somehow finally fully tamed with a great framework that handles all the goofy needs of specific shops, my preferred compromise is to use "smallish" abstractions, AKA "helper routines" that can optionally be used to simply things, but are NOT required. I like to say you need a way to: date your abstractions, but not marry them.
And these components have sub-components that can be partially used as needed also so that I only have to reinvent 1/3 of the wheel if I can't use the whole component. That way real-world requirements that "break" my larger-scale abstractions don't entirely boot me out of the framework (to be left hand coding all the details) because I can still use most of the smaller-scale abstractions that the bigger ones were built out of. It's kind of a fractal "next resort" down the abstraction ladder.
It's not perfect, but a decent compromise between hand-coding all from scratch and (alleged) do-it-all frameworks (like TFA) that are not flexible. But, you do have to know the parts well.
Table-ized A.I.
Ok, there are a lot of people commenting on this below who have absolutely no idea what reactive programming is about. So I'll try to clear it up a bit.
Reactive programming is not polling.
If you call a function and wait for it to return a result, you aren't doing reactive programming.
If you are working in a REPL or command-line environment, and you have to type a command every time you want to obtain a result, your system is not reactive.
Reactive programming is not events and triggers. Well... let's say it this way: reactive programming is to events/triggers as writing in [C/C++/Java/C#/Haskell/etc.] is to writing in assembly. In other words, you really could do the same exact thing with events or triggers than you can do with reactive programming. But events and triggers are very basic compared to what is meant by reactive programming.
Events and triggers are typically used when a little reactivity is needed. When you build your system around reactivity, using events and triggers quickly becomes inefficient and you need something built for the task. You would pick a reactive programming language or framework for such a complex job, just like (most of) you would choose high-level languages and frameworks over assembly for building a social media website.
Reactive programming isn't an agile framework. It's not some new way of describing object-oriented programming. And it's not the right tool for every job, but for some jobs, it's the perfect tool.
All my liberal friends think I'm a conservative, all my conservative friends think I'm a liberal.
That is one of the least informative articles I have read in a long time.
In fact I feel dumber for having read it.
It picks numbers out of thin air for the "standard programing" model,
then it has some magic pixie dust that represents the result in
reactive programming as a few lines of code.
I was thinking along the same lines, except that I would say 'relational' rather than 'SQL' because SQL is neither the only nor the ideal implementation of the relational model.
In one significant way they are different, however. Part of Codd's insight was that the deductive power of his model should be less than Turing-complete, so that issues of undecidability don't arise (triggers were not part of Codd's model.) This restriction made automatic query optimization and reasonable transaction times feasible, while those (relatively few) problems requiring the power of a Turing machine could be handled in a Turing-equivalent host language.
In contrast, the proponents of 'reactive programming' seem to be wandering into the realm of logic programming, which has been around for at least 4 decades (Prolog), without giving any indication that they are aware of its pitfalls.
Just like OOP eventually breaks down into CPU instructions, and you can use any Turing complete language to implement anything, I think he has a fair point. It sounds like a way to design a language so that complex event/trigger type stuff are easier to implement and debug systematically, perhaps using a slightly different way of thinking. It might not be a fancy thing, but I don't think there's anything wrong about giving it a name.
Your filesystem notifications or DB reactions are either coming from a polling loop in the FS/DB engine, or from an event processing loop in the FS/DB engine.
The system calls you use isn't the question. It's about how your implementation works, not about external implementations you don't control.
Let's think hierarchically. Make is smart and will check all intermediate output, all the way down to the leaves of its target tree, to see if it needs to do anything. If all the leaves are older than the final output, make doesn't do anything. If a level 5 leaf is younger than the final output file, make reevaluates that leaf and its level 4 parent, its level 3 grandparent, etc. to the top. It will use any intermediate outputs that were already generated where possible.
Here's where reactive is different: true reactive programming would being at the level 5 leaf that changed, as a direct result of it being changed. No continuous polling loop would be used in your implementation (again, the OS implementation is external to this). Such a "make" would not even need to make any check on the file modification date/time. It would know that the file it is notified about will always be the direct reason for causing a recompile, and it would go up the tree to produce its intermediate outputs as well as the final output, just like normal make.
All my liberal friends think I'm a conservative, all my conservative friends think I'm a liberal.
There is an anti-learning bias I think. More and more programers who think the past was stupid and not worth studying, with languages that only old irrelevant people learned, and system designs that are irrelevant for today, and theorems and equations that are hard and difficult and thus to be skipped.
Don't kid yourself that it isn't fundamentally a style implemented with events.
I suppose that's why I said:
... you really could do the same exact thing with events or triggers than you can do with reactive programming. But events and triggers are very basic compared to what is meant by reactive programming.
All my liberal friends think I'm a conservative, all my conservative friends think I'm a liberal.
It's a level of abstraction. If the only difference is that a "reactive" paradigm allows you to write the same code in less lines, each of which is less complex, it's an improvement over creating events/triggers. I don't know whether that's actually the case, but if it is, the above applies.
I don't know Val Huber, but can judge his "technology" ( hardly worth that name, though ) by what he is doing: putting the logic of a server-side application inside an RDBMS. After years and years of Hibernate applications with abysmally bad mainainability, now that finally finally finally-thank-god there are mature no-SQL databases, this guy goes back to where we were in the 80s.
Moreover: comments on that article simply get suppressed. Which says enough about this guy's capability to sustain critical thought. Dupe. Total dupe.
Religous speak to God. Insane are spoken to by God. When all shut up, one can finally hear Shostakovich in peace
When would I find time to read when I'm already so busy inventing?
try this with any real-world problem beyond this simplistic example and you'll be so deep in a mess that you'll yearn to have even COBOL back.
also good luck becoming familiar which such a codebase (er, trigger base) after just 3 months worth of iterations. the only reason for such an approach to imply "reduced maintenance" is that it would be absolutely unmaintanable. real world apps don't have 500 loc, they have more like 500k. good luck grasping the behaviour of a system staring at 200k worth of triggers. so now, good boy, go ahead and change just one of them and be fascinated by the impact. oh, these kids with their brand new macs ... i lov'em, they are soooo funny and they make us old hacks soooo indispensable! :-)
They were handing out the blue pills, not the tasty yellow ones. So, not so good.
They make me feel like I've been chewing on aluminum foil for an hour.
Sleep your way to a whiter smile...date a dentist!
... you really could do the same exact thing with events or triggers than you can do with reactive programming. But events and triggers are very basic compared to what is meant by reactive programming.
I kind of get the diretion you're going in, but I stil don't see. can you give an example? I see your analogy about C++ versus assembly but I only really understand it because I nuderstand C++.
Presumably reactive programm automates some (how/what?) or many or most of the difficulties away...
SJW n. One who posts facts.
You've told us what it isn't. That's as much use as telling us that strawberries are not yellow and curved.
Confucius say, "Find worm in apple - bad. Find half a worm - worse."
Sounds a lot like excel is changing it's name. I'm not sure that this programming technique is anything other than the brackety crap you type into the tiny text box at the top of an excel worksheet... you know, that thing that leaves you wanting a programming language for anything more complex than summing a column or sticking two bits of text together.
... in a schema ... nice! Not.
From the linked article:
Enhanced Quality
Encapsulating logic into database column definitions (across a variety of possible architecture) ensures automatic reuse of the logic across use cases.
I nearly fell of my chair.
The point of new paradigms in programming languages is to make the complexity of the expression match the complexity of the idea being expressed, not the complexity of the (platform specific) implementation.
Crappy illustration:
C++ - Event-trigger
// event
// trigger
// actual code you want to get around to actually writing
// some routine that modifies a continuously
vector triggers;
void add_trigger(Trigger * t);
void reactive_variable::modify_value(int new_value)
{
this.value = new_value;
for (i = triggers.begin(); i != triggers.end(); i++){
i.react(new_value);
}
}
int main()
{
reactive_variable a;
Trigger *b = new Trigger(COPY_VAR);
a.add_trigger(b);
Trigger *c = new Trigger(ADD_VAR, 1);
a.add_trigger(c);
a.modify_value(2);
enter_event_loop();
return 0;
}
Incomplete, inelegant and probably buggy, but you get the picture.
Verilog - Reactive
assign b = a;
assign c = a+1;
inital a = 2;
always @(posedge clk)
a = count(input);
Easy to understand whats going on and spot errors. 'b' will always equal 'a' and 'c' will always be one more.
so Reactive Programming is basically syntactic sugar making event handling a bit easier.
Fair enough... though I can't help thinking of Node.js and all those callbacks being heralded as a new revolution in programming when I hear about this stuff. As an old fart, I know there's nothing really new... just kids who think they need any new paradigm because they never had the balls to learn how the old stuff worked.
Reactive programming is based on the totally opposite concept of COME FROM statement. Waiting for a future Dijkstra to write a paper on how evil COME FROM is.
sed -e 's/Chuck Norris/Rajnikant/g' joke > fact
Actually, that's a good illustration, thanks!
Especially the bit about hardware. I guess if = just means a wire, then if one side changes, then so does the other. I guess you'd have to insert a D-latch to make it non-reacive. I guess nothing in the assignments is clocked.
I expect with care and crazy templates you could make a reactive framework for C++ if one chose.
SJW n. One who posts facts.
There was once a language called magic that allowed this to be done and was really good at it. A bank wrote their system with it. Then 5 years later someone tried to re-write the banking app. 10 years later they're still reverse engineering the original app to provide the functionality.
as it is eaten so it shall pass
This crowd is merely giving us another entry in the rather long list of isomorphic systems that differ only in their terminology.
Hey, if it gives the marketing folks a way to keep themselves busy, while I get to keep doing things the same way as always, it sounds like a win for everyone.
The downside of reactive programming, however, is exactly the same as the downside of the event/trigger logic that has been available in databases for decades, namely the difficult-to-trace side-effects caused by out-of-order execution that is basically mandated in reactive programming.
It's not so obvious when you're first writing code, but it's a headache when you're maintaining it (I disagree with the article on this point). Take the example in the original article... let's say you go back and add a requirement that people can pay for multiple invoices at once or for partial amounts. You have to check every single trigger to see if it refers back to the original payment information and adjust it accordingly. You'll have to change the data model to handle partially paid components (currently "paid" is a boolean), and any trigger that reads or modifies "paid" will have to be adjusted.
This alone isn't a problem -- you'd have to make similar changes in OOP, procedural, or functional languages... the issue is that in those languages you're more likely to be able to trace the dependant code and understand the flow. If you have access to the entire code base, you could search it I suppose, but each trigger operates like a "COME FROM" command in INTERCAL... it's as if your code is running along operating and all of a sudden an execution branch just pops in, performs some change, and lets you carry on, without telling you. I've had to debug some brutal issues caused by this sort of programming and it's difficult precisely because you're not sure where the execution path is coming from nor in what order it's being executed. It's almost entirely un-auditable once it gets complex enough to perform real-world tasks. If this was a real-world billing system, you'd have payments, refunds, discounts, credits, and a dozen other bits each making each "reaction" more complex. Each would require its own line of reactive code and each would depend on at least several of the others, and it's very easy to lose track of what's going on.
I realize people can write bad code in any paradigm, but bad code in reactive is far more difficult to debug, fix, and maintain, IMHO.
I guess hardware is always reactive, you just get to decide what it is reacting to and any one point. Reminds me of a micro architecture lecture where someone asked what happens if you don't put a value on the opcode port...
From the article, I think the idea is to enable hardware-like features to programmers.
It's not clear (and other posts are clearly as confused about this) whether reactive programming is meant to be a language-level paradigm (which IMHO would be interesting and useful) or some kind of 'philosophy' like agile.
If the latter, then I guess it would be about creating frameworks, which would get seriously messy, or some kind of meta-programming.
For C++, I think Qt-style signals and slots is the best you're likely to get, since you don't need to care how the event loop and triggers work, you just 'emit' in the right places and 'connect' up whatever object you'd like to change accordingly.
I don't know why people keep submitting this garbage from Espresso Logic, who is just taking advantage of the fact the the term "reactive" has been overloaded to mean different things to exploit the hype surrounding the Reactive Manifesto and related technologies (e.g., Akka, Rx, Node.js, etc.) to push their own, completely unrelated product, which is based on the more traditional (i.e., the one you find in Wikipedia) definition of "Reactive Programming".
"Reactive programming", as defined by the Reactive Manifesto (which is what all the hype is about), is about designing applications that operate in an entirely asynchronous and non-blocking manner, so as to maximize CPU utilization and fully exploit parallelism, and ensure that the system is always responsive to new events (user input, incoming data streams, errors, changes in load, etc.) rather than having resources tied up waiting for external processes (e.g., blocking on I/O). It has nothing to do with "reactive databases".
cp /dev/zero ~/signature.txt
This seems like the way nodejs works, where everything is done in a callback (anonymous function). Maybe you layer a triggering framework on it but that's all it is.
This is the second "reactive programming" article and I don't think it's anything other than callbacks. Someone is trying to get PR for some paradigm they think they invented.
Slashdot's rate-of-post filter: Preventing you from posting too many great ideas at once.
Yes and no. Really its just javascript callbacks. The QML system is just giving you a framework of automatic callbacks. At the core it works a lot like nodejs
Slashdot's rate-of-post filter: Preventing you from posting too many great ideas at once.
Yeah, that's "reactive programming" at the file level. I do it all the time, with Makefiles. ...
But that isn't reactive; it's still polling. ... you have to type "make [...]" or set up a cron job, you aren't doing reactive.
So who said anything about typing "make"? It's quite common for, e.g. a web CGI program to start a "make" process after the client input has been written to the appropriate files. The CGI program can then proceed or exit, and make's updates will happen in the background. It's also not uncommon to see Makefile commands of the form "cd some/dir; make foo" as part of the update process.
This isn't materially different from a write/assign triggering a cascade of updates via some routine deep down in the system library or OS. Its main advantage is that it gives the programmer better control of exactly when the updates are triggered. In the languages I use for CGI (bash, perl, tcl, python) it's also easy to check for the completion of the "make" process, and you can also get the error messages if you need them. My investigation of "reactive" libraries didn't spot any way to do this, though I could easily have missed it.
Aside from syntax, a set of Makefile entries are conceptually similar to the rules used in a "reactive" language. Which is better probably depends mostly on your application.
I don't remember ever setting up a cron job that does makes, but I'd imagine it could be a practical approach in some cases, when it's not important that the updates be done quickly. I do have one web site that I'm responsible for where the CGI processes finish by checking their process id, and if it's a multiple of 100, run "make clean" to clear out old log files, etc. But this isn't really the same thing. In perl, it's a one-liner: system 'make clean &'.
OTOH, I have seen an annoying problem with a low-level "reactive" tool: Suppose that A depends on B, C and D. If all three change, this tends to trigger three updates of A that overlap. This is at best a waste of CPU time, and it can lead to race conditions in complex dependency trees. Using the "make" approach, if the changes to B, C and D are done by a single process or a set of communicating processes, it's easy to delay the update until all the leaf data has been written, when a single update process can do all the updates. This is much easier to program correctly. Of course, a well-designed reactive library might provide ways to control this, but the result would probably be isomorphic to the "make" approach.
(And firing up a "make" process isn't cheap. It could be useful to have an equivalent process running permanently, with updates triggered by an inter-process message. But this is merely an efficiency gain; it's still logically equivalent to a "make" command.)
Those who do study history are doomed to stand helplessly by while everyone else repeats it.
Both slashdot articles are authored by "ValHuber" who works at Espresso Logic Expresso Logic's web page is bannered by
"Reactive Service for SQL Data
RESTful API with reactive logic and security in 4 easy steps
Dramatic reduction in development & maintenance time"
I think it is time we stop marketing for this consulting company.
Slashdot's rate-of-post filter: Preventing you from posting too many great ideas at once.
This is just forward-chaining logic programming. I.e., if x changes then do y, and people have been using this in design for years - several large vertical applications have this feature built in.
The problem with this kind of code is that, when there is contextual dependency on what is to be done (which happens often in real life), the code becomes riddled with special cases accessing data from far flung parts of the system to determine the contextual state - this starts to look akin to spaghetti code with everything accessible from anywhere in the program: Hello, global state!
The other problem is that, without fixed flow of control, debugging becomes more difficult, even if you have a specialized debugger that doesn't make you trace through the machinery.
Plus, people not used to this kind of programming will embed code which must be specifically ordered within one or more triggers not realizing that trigger orders are usually unspecified, leading to fragile code.
In the end, this is just like any other programming paradigm - useful for things that it's useful for, not so useful for things that don't fit well. You should know how to program on systems like this. You should also know how they're implemented so that you don't screw up when you have to program in one.
That is all.
Is "Reactive" logic an event-driven model with reused logic for column calculations/validation?
You really must be an expert, because I haven't understood a damned thing by reading your explanation...
This is a UDP joke, I don't care if you get it or not...
You've clearly never heard of Bennet Haselton.
Confucius say, "Find worm in apple - bad. Find half a worm - worse."