<conan> but hen  also from a consequence
<mfusco> conan, I just don't see a practical use case tbh
<conan> send and receive?
<conan> you dont think an application needs to send message ?
<mfusco> sending a message to a node, yes
<conan> and receive and process the results?
<mfusco> an entire application yes
<mfusco> mmm, 1 min let me reread what you wrote, I guess I misunderstood you
<conan> mfusco  imagine for instance I want to have one rule that handles all responses first.
<conan> so lots of consequences submitting async tasks, or messages.
<conan> I setup one receive node, and everything goes through that.
<conan> end of the day, all we are doing is allowing something external to insert directly into a node and continue propagation - instead of inserting into the working memory.
<conan> and done in a thread safe and efficient way
<mfusco> what's the diff in inserting into the ksession? (or an EP)?
* paulovmr (~paulovmr@redhat/jboss/paulovmr) has joined
* ChanServ gives voice to paulovmr
<conan> mfusco  you'd probably code up snd/rvc nodes in a day - if we leave our DRL.
<conan> it would be worth doing
<conan> just to check canonical model is "good enough"
<conan> and it would start to make you think about reactive programming models more :)
* evacchi (evacchi@nat/redhat/x-ikcyuibtjxltonys) has joined
<jbossbot> git [drools-website] push master bca2d34.. Michael Biarnés Kiefer New menu (#67)... http://github.com/kiegroup/drools-website/commit/bca2d343e
<jbossbot> git [drools-website] push master URL: http://github.com/kiegroup/drools-website/commit/bca2d343e
* conan has quit (Quit: Computer has gone to sleep.)
* cchianel is now known as cchianel|mtg
* tsurdilo (~tsurdilo@2600:1700:3d70:c50:8585:deb6:f8c7:b3b8) has joined
* mbarkley (~mbarkley@107-159-15-38.on.dsl.ebox.net) has joined
* michaelbk has quit (Remote host closed the connection)
* cimbalek has quit (Ping timeout: 240 seconds)
* michaelbk (mbiarnes@nat/redhat/x-kaqxslyptabyqzem) has joined
* tdavid (tdavid@nat/redhat/x-aepowjmtvufimowk) has left
<jbossbot> git [droolsjbpm-integration] push 7.7.x 3913b2b.. Maciej Swiderski JBPM-7190: filter parameter is not a required param in Swagger definition. (#1449) (#1451) http://github.com/kiegroup/droolsjbpm-integration/commit/3913b2b1c
<jbossbot> git [droolsjbpm-integration] push 7.7.x URL: http://github.com/kiegroup/droolsjbpm-integration/commit/3913b2b1c
<jbossbot> jira [JBPM-7190] Filter parameter in RuntimeDataResource.getProcessesByFilter is not required [Pull Request Sent (Unresolved) Bug, Major, KieServer, Maciej Swiderski] https://issues.jboss.org/browse/JBPM-7190
* cwatkins (~cwatkins@103.51.117.68) has joined
* ederign (ederign@redhat/jboss/ederign) has joined
* ChanServ gives voice to ederign
<mfusco> etirelli, can you please pm_ack this? https://issues.jboss.org/browse/RHPAM-795
<jbossbot> jira [RHPAM-795] Deadlock in Drools ProjectClassLoader when starting Business Central [Pull Request Sent (Unresolved) Bug, Blocker, Business Central, Mario Fusco] https://issues.jboss.org/browse/RHPAM-795
<etirelli> mfusco: done
<mfusco> etirelli, thx
* cwatkins has quit (Quit: Leaving)
* jhrcek has quit (Quit: Leaving)
* ddoyle (~Adium@92-108-179-146.cable.dynamic.v4.ziggo.nl) has joined
<dzonca> etirelli: I looked at https://issues.jboss.org/browse/RHDM-181
<jbossbot> jira [RHDM-181] Not possible to use Stateless session in Test Scenarios [New (Unresolved) Enhancement, Critical, Decision Central, Daniele Zonca] https://issues.jboss.org/browse/RHDM-181
<dzonca> did you assign to me that item just to remember in the new implementation to support Stateless Session or do you want I try to fix also in the current one?
<etirelli> dzonca: this is just to "remember" to fix it in the new editor... not fix in the current one
<dzonca> ok
<etirelli> dzonca: it is waste of time changing the current one
* cchianel|mtg is now known as cchianel|wfh
* cimbalek (mcimbale@nat/redhat/x-xlpjoqbrthpofvmk) has joined
<dzonca> etirelli:  at the same time if we want to support Stateless and Statefull in the new implementation we will probably need to change a lot the fluent API because KieSession and StatelessKieSession are almost completely different
* maciejs has quit (Quit: Leaving.)
* cchianel|wfh is now known as cchianel|wfw
* cchianel|wfw is now known as cchianel
* viyengar (~viyengar@106.78.201.116) has joined
<ederign> tzimanyi mfusco ping
<tzimanyi> ederign Hi
<ederign> tzimanyi hi! any news about https://github.com/kiegroup/drools/pull/1874 ?
<jbossbot> git pull req [drools] (open) Tibor Zimanyi RHPAM-795 RHPAM-55 Register project classloaders as parallel capable https://github.com/kiegroup/drools/pull/1874
<jbossbot> jira [RHPAM-795] Deadlock in Drools ProjectClassLoader when starting Business Central [Pull Request Sent (Unresolved) Bug, Blocker, Business Central, Mario Fusco] https://issues.jboss.org/browse/RHPAM-795
<jbossbot> jira [RHPAM-55] Java-level deadlock after cloning a repository [New (Unresolved) Bug, Critical, Business Central, Eder Ignatowicz] https://issues.jboss.org/browse/RHPAM-55
<tzimanyi> ederign I think it is waiting for merge
<ederign> tzimanyi mfusco this is probably related with https://issues.jboss.org/browse/RHPAM-55
<jbossbot> jira [RHPAM-55] Java-level deadlock after cloning a repository [New (Unresolved) Bug, Critical, Business Central, Eder Ignatowicz] https://issues.jboss.org/browse/RHPAM-55
<tzimanyi> ederign yes, I linked that in the PR name
<ederign> tzimanyi mfusco do you think it will make it for friday?
<tzimanyi> ederign not sure, depends on mfusco opinion
<mfusco> ederign, tzimanyi, sorry in a meeting
<mfusco> reading
<tzimanyi> mfusco I will prepare the backport to 7.7.x, is it ok?
<mfusco> ederign, yes I just have to merge tzimanyi's fix, I'll do before EOD
* viyengar has quit (Ping timeout: 240 seconds)
<mfusco> tzimanyi, not necessary, I'll cherry-pick your commit
<mfusco> tzimanyi, thanks
<ederign> mfusco great thank you!
<tzimanyi> mfusco ok thanks
<ederign> tzimanyi thanks!
<ederign> tzimanyi do you want to have PAM-55 assigned to you?
* mbarkley has quit (Ping timeout: 248 seconds)
<tzimanyi> ederign not needed, just resolve it when merged
<tzimanyi> and link the backport commit
<ederign> tzimanyi ok!
* conan (~conan@94.119.64.2) has joined
* egonzale (~egonzalez@89.29.168.67) has joined
* wmedvede has quit (Quit: Leaving)
* wmedvede (~wmedvede@165.169.19.95.dynamic.jazztel.es) has joined
* lclayton1 (lclayton@nat/redhat/x-iaohchzjcxisnygi) has joined
* mweiler has quit (Quit: Leaving.)
<conan> mfusco  back
<conan> mfusco  anyway a send/rvd node will take only a few hours - if we do it at hte model level.
<conan> its' really very simple.
<conan> mfusco  when you want to attempt it, let me konw. I'll talk you through it.
<conan> mfusco  we already have the basis for this. via the TimerNode.
* ksuta (ksuta@nat/redhat/x-uxgnkygfwqtfjwpj) has joined
<conan> it's just a variant of this
<conan> the send is a variant of the 'from' node
<conan> the receive a variant of the timer node
<conan> we can do both purely at the model level
<conan> mfusco  it will be actually quite cool to do. and will bring value for drools to thread safe reactive programming models.
* michaelbk has quit (Quit: Leaving)
<mfusco> conan, the send/rcv node is a EPN?
<dzonca> conan: you told me about support units in API
<conan> no
<conan> not really
<conan> mfusco  EPN is different.
<dzonca> I read about them in the documentation, what's your idea?
<conan> mfusco  it's are chains of engines. And you setup "queries" that select and forward data to the next node.
<conan> so every node has a process, selection and forward phase.
<conan> process the incoming data, select data for forwarding with queries.
<conan> mfusco  but that's something we should do
<conan> crazy we haven't done it yet
<conan> it's so trivia lt do now
<conan> we just need to make sure the usage pattern works well for drools
<conan> figure out the batching
<mfusco> thinking
<conan> mfusco  the idea with an EPN is to maximise the over all throughput
<conan> but you don't always konw at what rate stuff comes in
<conan> that and ofcourse do splits and joins
* jomarko has quit (Quit: Leaving.)
<conan> so you split data, to a fan out of processors, select and forward o the joiner.
<conan> well after the split, it can still go through a chain of procssors, until it does the join.
<conan> not everything is always piped forward
<conan> you have an "event cloud"
<mfusco> processors == filters ?
<conan> so any node in the EPN can detect a composite event, and publish to the event cloud
<conan> mfusco  a processor here is just a normal drools rule
<conan> it's going to select and act on data
<conan> so imagine a "node" has two aspects to it
<conan> one is just a normal drools rule. that processes isnerted data - select/filtering and executing actions. then the next phase is to use queries to select what is to be forwarded.
<conan> now if you keep this stateless, and only working on a single object type - it's very trivial.
<conan> but you cannot guarantee that
<mfusco> no joins?
<conan> well it can
<conan> I'm just talking about the simplest use case
<conan> which is valid
<mfusco> ok
<conan> some organisations will not have joins
<conan> others will
<conan> and with those jions, data can come from two places
<conan> either via the pipeline - like any other data - or "background" data, that is loaded into the engine.
<conan> like lookup data
<conan> so you can pre-popualate an engine with data that is used ot help process date going through the pipeline
<conan> dzonca  hi, yes sorry. mis conversation :)
<conan> s/mis/mid/
<conan> dzonca  make it work for units.
<conan> dzonca  and edson says, make it work for stateless.
<conan> dzonca  there is a separate aspect, we never made units work on stateless yet.... :)
<conan> dzonca  look at docs and unit tests, to see units.
<mfusco> conan, will you be at Summit? can we please rediscuss it there? I'm a bit lost :)
<conan> mfusco  how? it's soooo easy :)
<conan> evacchi  ^ you following the scroll?
* mczernek_ has quit (Ping timeout: 255 seconds)
<conan> evacchi  two topics. back to the prova snd/rcv nodes. but separately what an EPN is.
* marekn (mnovotny@nat/redhat/x-kmiqyuhtlbvkvxaf) has left
<conan> mfusco  we could just model the whole thing locally first too.
<conan> it's just an example
<evacchi> dzonca: prova is http://prova.ws
<jbossbot> Title: Prova language for rule based scripting of Java and agents, and knowledge and information integration
* etirelli has quit (Ping timeout: 260 seconds)
<conan> mfusco  maybe we should just do that. setup a model for chaining pipelines on a machine - you can just do in separate threads.
<conan> mfusco  just as a learning exercise.
<evacchi> trying to see the connection between EPNs and snd/rcv
<conan> can simulate the whole thing as just a usage pattern, on a local machine. before going machine distributed.
<conan> mfusco  but either way I'd start with the snd/rvc node
<conan> because I've probably spent more time epxlaining it, than it would take to do :)
<conan> mfusco  it is deceptively simple. we already have the foundations in the nodes for this.
<conan> mfusco  want to do it tomorrow? :)
<mfusco> conan, I need to finish customer's use case for executable model, but almost done
<conan> ok
<mfusco> conan, yes, I could give it a try tomorrow
<conan> ping me. lets do this, it won't take long. just to get it out of the way.
<mfusco> conan, but first I need to reread prova docs
<conan> you don't need to read all of it
<conan> just the snd/rvc
<mfusco> conan, yes, that bit, I'm not fully understanding
<conan> but I can talk you through it too
<conan> as in specifically not to impl.
<conan> 1) 'from' can already execute any code. So have 'from' snd a message, the result is just a single object (the correlation id). 2) next node is variant of the timer node. The correlationId is on the left input. When the message returns, the node picks it up (in a thread safe manner, as per TimerNode) and does the join and continues.
<conan> that's it
<conan> we do exactly the same thing to correlate a Timer Node with the job.
<conan> mfusco  that's the basic, first iteration.
<conan> mfusco  simples :)
<conan> you can even just use a 'from' node for the first iteration, nothing extra needed for the snd. We can optimise it later.
<conan> mfusco  getthing that so far?
<conan> mfusco  what it means is we can have distributed reactive programming, without blocking network evlauation while we wait for the message to return.
<conan> a simple use case.
* dgutierr_ (~dgutierr@143.red-83-60-243.dynamicip.rima-tde.net) has joined
<conan> mfusco  lets say a "join" needs remote lookup data, this takes time, we don't want to wait on it.
<conan> so this way the 'join' can request what it needs, and will continue once it has it - without blocking/wait code.
<conan> mfusco  that's your first use case :)
<mfusco> the timer is not really a timer, is just for async exec, right?
<conan> mfusco  no there is no timer.
* etirelli (~etirelli@toroon2717w-lp140-01-69-158-176-169.dsl.bell.ca) has joined
* etirelli has quit (Changing host)
* etirelli (~etirelli@redhat/jboss/etirelli) has joined
* ChanServ gives voice to etirelli
<conan> mfusco  but the TimerNode shows you how an external thread can safely inject data into a node, and signal for that node to be evaluated. all in a thread safe manner.
<conan> that's the key
<mfusco> ok, getting it now :)
<conan> and it shows off the value of our state machine
<mfusco> so this works on the timer thread of the state machine
<conan> so that we can do really efficient correlated async operations, while still having a single thread engine.
<mfusco> now I see
<conan> mfusco  well not necessarily the timer thread
* dgutierr has quit (Ping timeout: 276 seconds)
<conan> it would be it's own thread
<conan> it would just use the same concept
<conan> the timer after all is just some external thread, that eventually wants to shove something into a node.
<mfusco> I mean a thread coordinated by the state machine as it already happens with timers
<conan> so we should allow other threads to do the same
<conan> mfusco  you can do this generically.
<conan> so that anyone that implements an interface, can have an external async processor that can have thread safe co-ordination with a join node.
<conan> it would allow people to plugin anything they want
<conan> JMS is jsut the first example
<conan> but it should be provider based
* tbento is now known as tbento_afk
<conan> mfusco  making more sense now?
<mfusco> conan, ok, I just need to reread prova docs, but now it's clearer
<mfusco> yes
<conan> told you it's simples!!!! :)
<conan> it's probalby how I describe it
<conan> but we've spent more time talking about it
<conan> than it'll take to do
* etirelli has quit (Client Quit)
<conan> always put it off before, as it would be a pita for DRL.
<conan> but with canonical model, we can POC this stuff fast.
<conan> and have full working examples
<mfusco> ok
<lclayton1> anbaker, dzonca: do you guys have any time for a quick chat?
<conan> mfusco  we may be able todo this better.
<conan> such that we make a base node
<conan> extracted from TimerNode
<conan> and then TimerNode can just extend that
<conan> and we do another one that extends it, for user provided external.
<conan> mfusco  look at TimeNode. scheduleTimer.
<conan> now if oyu remove all the logic about hasNextFireTime etc - which is timer specific
<conan> the meat to the co-ordination is
<conan>             DefaultJobHandle jobHandle = (DefaultJobHandle) timerService.scheduleJob( job, jobCtx, trigger );
<conan>             leftTuple.setContextObject( jobHandle );
<mfusco> yes
<dzonca> lclayton1: I will be back in 10 minutes
<conan> so instead its leftTuple.setContextObject( asyncService.submit( ctx ) )
<conan> and then the rest of how it co-ordinates the finished job, to continue with the correlaed join.
<conan> that part is 100% identical.
<mfusco> true
<mfusco> so this is the receive part
<conan> I would just clone timernode to start with
<conan> remove the timer bits
<conan> get it working
<conan> then generify to a base shared node after
<mfusco> what is the send?
<conan> for this iteration you can use 'from' as is
<mfusco> got this
* tbento_afk has quit (Quit: This computer has gone to sleep. ZZZzzz…)
<conan> just inject a variable that does the send
<conan> it's a hack
<conan> but quick
<conan> we can improve later
<conan> this pattern is for when there is specific correlation between a snd and subsequence rvc.
<conan> but there are others
<conan> if we "label" a received
* karreiro is now known as karreiro_afk
<conan> then any send (node) or consequence could submit something,that is received by a node in another rule.
<conan> or even have a generic receive that receives everything
<conan> you could also have a fanout on receivers, with the label approach.
<mfusco> a publisher/subscriber?
<conan> I guess in this case labels become like channels
<conan> but I guess once step at a time :)
<conan> mfusco  yes I think so.
<mfusco> ok, sound a nice experiment
<conan> mfusco you could setup a rcv node, directly on the end of a vert.x, to consume stuff.
<mfusco> I'll finish with customer's PoC and then I'll give this a try
<conan> only thing I can think though about vert.x
<mfusco> yep, that could help also with vert.x intergration indeed
<mfusco> I was thinking just the same
<conan> with vert.x is it already taking care of the single threadedness?
* mbarkley (~mbarkley@38.104.156.250) has joined
<mfusco> vert.x requires everything to be async
<conan> i.e. by the time you attach your handler, you can assume it's guaranteed single threaded?
<mfusco> so no, usually there are many threads involved
<conan> ok
<conan> just want to make sure vert.x is trying to handle some of the logic, that might be better handles via our state machine.
<mfusco> I don't think so, but I need to check
<conan> mfusco  we get this right. flesh it out enough. we can start to make a play for reactive programming models.
<conan> our state machine is probalby fairly unique, for the complexity it can handle.
<mfusco> yep
<conan> mfusco  and then prmote it via projo rules.
* cimbalek has quit (Ping timeout: 240 seconds)
<mfusco> sorry, I need a coffee, I'll be back in 10
<conan> anyoen doing vert.x, is using rxjava. so they'll be very happy with our pojo rules from us.
<conan> mfusco  no problem,  I probably flooded your brains :)
<conan> mfusco  so tets do this snd/rvc. once you understand that, we'll work through various use cases
<conan> the EPN, we'll do another day.
<conan> again this is not difficult, the basic versino - just usage pattern of drools.
<conan> but I think we can probably do it better, by baking some things in - once we figure it out.
<conan> I'm not sure what the answers are there, we need to research it via spikes.
<conan> but i have ideas :)
<conan> dzonca  sorry long scroll.
<conan> dzonca  did mario provide you with link to units test cases?
* ddoyle has quit (Quit: Leaving.)
* ddoyle (~Adium@92-108-179-146.cable.dynamic.v4.ziggo.nl) has joined
* ddoyle has quit (Client Quit)
* etirelli (~etirelli@redhat/jboss/etirelli) has joined
* ChanServ gives voice to etirelli
* ddoyle (~Adium@92-108-179-146.cable.dynamic.v4.ziggo.nl) has joined
* mhussain has quit (Ping timeout: 240 seconds)
<conan> mfusco  prova also uses annotations nice as a "guard" model. The same thing can be simulated via facts. but using labels that can be targetted to allow or block evaluation, is a nice higher level thing.
<mfusco> conan, reading
<mfusco> conan, yes I pointed dzonca to docs
<conan> mfusco  prova created this snd/rvc model
<kie-jenkins-bot> Project droolsjbpm-integration build #760: UNSTABLE in 1 hr 48 min: https://kie-jenkins.rhev-ci-vms.eng.rdu2.redhat.com/job/droolsjbpm-integration/760/
<conan> so prova could be an Actor
<mfusco> yep, that's very similar to the actor model indeed
<conan> so it's how prova could be wired up to akka or equivaent
<conan> mfusco  https://prova.ws/confluence/display/RM
<conan> it's all htere
<jbossbot> Title: Reactive messaging - Reactive messaging - Prova Rule Language
<conan> they did good research
<mfusco> k
* mdessi has quit (Quit: Leaving)
* mdessi (~mdessi@dynamic-adsl-78-15-224-86.clienti.tiscali.it) has joined
* mwinkler has quit (Quit: Leaving)
<kie-jenkins-bot> Project droolsjbpm-integration-7.7.x build #49: STILL UNSTABLE in 1 hr 38 min: https://kie-jenkins.rhev-ci-vms.eng.rdu2.redhat.com/job/droolsjbpm-integration-7.7.x/49/
<kie-jenkins-bot> noreply: JBPM-7190: filter parameter is not a required param in Swagger
<jbossbot> jira [JBPM-7190] Filter parameter in RuntimeDataResource.getProcessesByFilter is not required [Resolved (Done) Bug, Major, KieServer, Maciej Swiderski] https://issues.jboss.org/browse/JBPM-7190
* tzimanyi has quit (Quit: Bye)
* dgutierr_ is now known as dgutierr
* mhussain (~mhussain@125.16.97.114) has joined
* cchianel is now known as cchianel|lunch
<volothamp> mfusco: https://github.com/kiegroup/drools/pull/1876
* jpetrlik has quit (Quit: Leaving.)
<conan> mfusco  https://prova.ws/confluence/display/RM/Guards+in+message+processing
<jbossbot> Title: Guards in message processing - Reactive messaging - Prova Rule Language
* omolinab has quit (Quit: Leaving)
* lterifaj has quit (Quit: Leaving)
<conan> mfusco  https://prova.ws/etc/Prova%203.0%20User%20Guide%20-%20May%202010.pdf
<conan> see 1.8 guards in prova
<conan> mfusco  again the key to understanding prova, is understanding prolog.
<mfusco> conan, thanks
<conan> and that the LHS can be far more powerful than we have with pure production rules.
<conan> you can end up with more tight and succint solutions
<conan> that trying to do everything through consequences
* conan_ (~conan@94.119.64.19) has joined
<conan_> mfusco  got disconnected
<conan_> [16:33:07]  <conan> and that the LHS can be far more powerful than we have with pure production rules.
<conan_> [16:33:17]  <conan> you can end up with more tight and succint solutions
<conan_> [16:33:24]  <conan> that trying to do everything through consequences
<conan_> [16:34:19]  <conan> mfusco it's hard to explain. but it's why I've said you thnk of the LHS as acutally more like a stateful and incremetnal "functinoal construct' as in functional programming.
<conan_> [16:34:25]  <conan> i.e. the LHS can be more like a utility
<conan_> [16:34:26] Disconnected
<conan_> [16:34:30]  <conan> than a business rule
<conan_> ---
* conan has quit (Read error: Connection reset by peer)
<conan_> just in case
<conan_> mfusco  of partcular interest in the docs, as well. are timers and reaction groups.
<conan_> "This example is somewhat contrived as there are better ways to achieve the same result using reaction groups. Here is a solution from hohpe_using_groups.prova. The sorted accumulator collects all offers sorted by the offer values. If the @size(1) annotation was not added to the exit reaction @or, the outputs would have continued every second. The @size(1) output just one collection with the results and the exit reaction extracts that first result and
<conan_>  prints the highest offer."
<mfusco> conan_, reading
<conan_> take a look at teh sample
<conan_> it's pretty cool
<mfusco> ok
<conan_> they are collecting all bids, over 1sec period.
<conan_> because of the way our system works
<conan_> everything has to go in ksession.insert
<conan_> or named entry-inserts
<conan_> and an entyr-point per node, would be rediculously heavy
<conan_> also bear in mind that the rcv has no "delete" so it has to be opimised for stream inputs (something else we discussed before). to optimise our network for streams (once we have marshalling fixed).
<conan_> mfusco righht now we only support timers as a declartion on a rule. but actually the timernode can be at any point in the network.
<conan_> mfusco  futher notice how prova is instantiating stuff on the LHS
<conan_> even doing printoutst
<conan_> Acc = ws.prova.eventing.SortedAccumulator(), @group(bids) @timer('1 sec','1 sec',Acc) rcvMsg(XID,self,Me,respond,[Service,Offer]), Acc.processAt(Offer,Service),
<conan_> println(["Received offer: ",Offer," from ",Service]).
<conan_> we can do the same, it's basically our "eval".
<conan_> there is no reaoson why you cannot do a printout in an eval (mid network).
<mfusco> yes, not really readable though
<conan_> it's just a different style
<conan_> prolog people wuold say it's far superior :)
<conan_> mfusco  alos see 1.10. Workflows and business processes
<conan_> now that fascinates me
* jlocker has quit (Quit: Leaving.)
<conan_> showing extensions to allow you to model BPM llogic in ruels
* egonzale has quit (Ping timeout: 240 seconds)
<conan_> if we tried to do that with production rules. while possible, it would get really verbose.
<conan_> and wasteful, due to the ksession.inserts
<evacchi> conan_: that example kind of sold the approach to me
<conan_> I'm not saying its not without problems
<evacchi> I'm not convinced about their use of annotations though
<conan_> but I think it's interesting
<conan_> yeah
<evacchi> I mean, it's weird how it fits in the prolog model
<conan_> but we need the foundations in
<conan_> so we can tinker with these things
* sr_pere__ (~sr_pere@212.red-83-39-105.dynamicip.rima-tde.net) has joined
<conan_> I need to expand mfusco's mind
<conan_> so we can explore, and see what works and what doesn't.
<conan_> half the battle, is getting people to think beyond simple business production rules
<conan_> evacchi  but now that mfusco gets the snd/rvc
<conan_> we have progress :)
<conan_> small victories
<mfusco> ok :)
<conan_> typically once those things are in place
<conan_> you can build on those abstractions, explore them, get greater understandings.