 Yeah, so finish the first milestone for the clicker Okay, so this is today you can see part of the rules team This is Fago the creator of the rules module Closie the commentator I do kind of organizing around the initiative that we have and There's also fooby helping out with development Steve Perkis and Nico green are did the great new logo for the rules initiative What is the rules module so hands up who has been using rules in the previous versions cool awesome who has not been using rules before Okay, cool. Thanks for sharing up still So the rules module consists of very basic principles We have any event that can happen on the website could be a user interaction It could be a crown job running in the background So the event is the trigger that fires and then we can test for arbitrary conditions so we can check in that case for example The user has generated the content has been updated event and then up here We can check for a condition. So if it's So in this example If the content author is different to that acting user But it could be any condition that you can think of and then we can execute Actions could be one action could be multiple actions in that case We want to notify the content author that another user has changed the content on the website So based on the principles events conditions and actions You being a site builder you being a developer Can implement very custom workflows and there is a couple of examples for that so The rules module is is being used to build flexible workflows for example Customized mail notifications. So instead of having a back ender Needing to implement the mails that are being sent out through the user interface via cost via clicking together the rules configuration You can customize the text that are sent out Or there you can also do custom redirects system messages a lot of other stuff but the big power of the rules module is Because There's hundreds of integration modules available so We have a big ecosystem Their entity API the fields the views modules. They all have integrations with the rules module and this is why Actually yesterday we checked it's not it's we've always been talking about this we used on every fifth Drupal site But it's already used on every fourth Drupal site. So more than 25% of all the Drupal installations use the rules module Yeah, which is kind of cool So it's maybe not the the hard requirement for people building websites But it's it has a very big adoption based on the big flexibility that the rules module provides Yeah, you probably know that already and this talk is primarily about Drupal 8 so We got really excited about Drupal 8 and I'm just very quickly recapping that well There's all of Drupal 8 will be object oriented We can have more modern web patterns Development patterns like dependency injection a lot of API's get better for Drupal 8 Everything is we can do more efficient testing with the PHP unit framework that is in place And Drupal 8 uses a lot of symphony components So that gave us a lot of motivation to port the rules module to Drupal 8 also that there's some legacy modules being removed web services are part of Drupal core now And the front end is responsive and so forth So yeah, we kind of had a lot of general excitement for Drupal 8 and when breaking it down to what is relevant for rules itself Actually, sorry just a second It's a bit weird because the slides are very small here Okay, so in Drupal 7 and the versions before rules was already I'd say leveraging back best practices Coding standards and it was already organized in a very modular and extensible way So actually group rules before already leveraged its own plugins System, but now we can use the plug-in system from Drupal 8 which is kind of cool and makes the code very Much more readable and understandable There's a conditions API in Drupal core so we can leverage that and we can also build on all the structured data That is now much more consistently available through APIs so the entity API now is a is a full leveraged API in Drupal 8 and The type data API has been Made generic again, which is kind of cool The actions API we have to put it in parent Yeah, we kind of had to fork it because we couldn't fix everything in Drupal core itself But we are building upon the the existing actions API And maybe in further to play point releases. We will be able to to push that code back into Drupal core itself Then the context API this is kind of exciting because there's already a Drupal 8 contract module the joint forces with us page manager Is using the same context system as the rules module does in order to pass in information Into different components of rules and return their structured and Metadata annotated information about which context are required and what are the return values of the actions perform? Yeah, and then in general configuration management so instead of implementing our own export system Site site builders or developers will be able to just use the CMI system in order to export configuration into YAML files Which is great We kind of try to to do it the best way as we can so Reusable components is a big topic for us So everything every problem that we solve we try to solve in a in a generic way And we have been talking about these are tools idea of it So the idea is that we for example the tokens that rose needs they they are its own component and The typed data widgets in order to configure rules and to display rules configurations that should be a reusable part and then the Yeah, as mentioned the context API that we're using it can it's extended in rules and could be used by other modules And we also want to have more integrated ability so that for example On the block con like when you have block visibility conditions That could just be a rules UI component where you don't have to go into the rules module itself to configure it But you it would just show up in another place. It could be reused So a big focus on reusable UI components and as you maybe Already know from the previous versions the data selector. It's kind of handy it's kind of cool to be able to drill into the all the data structures available and This doesn't have to be necessarily part of the rules module so we implement it in a way that other people can reuse it and Probably will it will just be its own library or its own feature along the way Right um for site builders I Think the biggest the biggest change would be the inline rule system that we envision so instead of Having to build rules configurations bottom up where you first define the rules components And then you assemble them together in in a reaction rule You would be able to build it top down because that's like the way we think about logic So when I have to implement more complex if and else Statements for example in Drupal 7 I have to install the rules conditional module or I have to really think bottom up By creating the components first Whereas with the inline rule system we envision that site builders would be able to build the structure top down Yeah, deployable configuration as mentioned by a CMI so That's like a lot of good things That we all would like to use right now, right And Fargo and me over a year ago. We decided it's not gonna happen unless Something is pushing us forward. So I'm quickly gonna explain what we did so far. There's a campaign Which is which goes by the name D8 rules and our vision is To accelerate through polite uptake by ensuring that the rules model as a key Contributed module is available for everybody so that people can build flexible workflows on their websites and We also want to find a way to make our Contributions like all the development time that we put into the rules module a bit more sustainable. So That sounds like funding right and on Drupal fund us we put up a campaign and kind of We're really successful. We had over 300 people pitch in smaller and bigger amounts of money and We also had a lot of corporate Companies Supporting us which is really great. So thanks a lot to all of them together We got a fun and we got a financing about 18,000 euros and that translates to 45 euro Self-cost of either epico or to nomics the both companies employing Closie and Fargo So they would they would allow their developers to work for the self-cost and in Austria. It's basically for 45 years You don't earn anything but you kind of let the people work on on contribution in that sense So That's really great. It was was kind of a cool accomplishment for us and it it enabled Closie and Fargo to to invest more time in order to to work on all all the topics that we have stated that was over a year ago and Until now we actually finished the first milestone. There's a there's a more detailed blog post on our website The rules.org where we explain what we have accomplished so far and we did a lot of interesting stuff on the way Yeah, like to have an overview so the milestone one is Kind of the basics of the rules core engine The plug-in types are all there You have the condition and action APIs. We actually already have event APIs as well So we are we also started working on stuff that was planned further ahead and Yeah, the parameter configuration and the context mapping and basically all that together my stone one Is what we call a developer preview? so if you are interested in porting a contribution module are From Drupal 7 to Drupal 8 that relies on Drupal on the rules module that has integrations its own custom events Its own actions its own conditions You can already start doing that by now That's cool, and then thank you Yeah, my stone two we reprioritized a bit so originally we only had the UI put at the very end But we felt without the UI. It's it's it's really boring and nobody will will want to use it So we reshuffled priorities a bit and we already have very Basic steps of the UI in place But we need definitely need a lot of help there and in order to be able to complete milestone two by the end of the year We would do Yeah, like the UI part one so that you can do the basic editing And then we'll do Yeah, we kind of complete all the engine features We'll also have the advanced Plug-ins like finalizing the events or we still have to implement the loops and so forth We'll have entity token support The configuration CMI integration that's already started. So there's already examples for that Then all the rules in the generic rules integration so that data is exposed And the reusable UI components and then finally at the end we have a lot of like Advanced tasks to finish and we're gonna complete the rules UI. We're gonna have the rule schedule apported and The existing integrations which also has already been started. So a lot of work has already been started a lot of work is ahead I think we have a good plan and we have actually a much much bigger team than I presented in the beginning So during sprints trainings and sessions We didn't only work on the module itself But we also trained a lot of contributors a lot of members on the new paradigms of Drupal 8 getting up to speed with With the plug-in system getting up to speed with the Context API. So that was a really great opportunity and we we have held sprints trainings and sessions at various trooper camps trooper cons Smaller sprint. So it's really great opportunity and this Friday. You're all invited to join us as well So there's more than 27 contributors that already have their pull requests merged and there's a lot of more pull requests around So thank you everybody for contributing. It's this which is awesome It really also motivates us a lot to push things forward and get get the module finished. Thank you Yeah, and now Fargo will take over So if you are interested in helping out We really made sure that is that is as easy as possible So basically what you you need is just a triple 8 installation and then you go to our github page It's github.com slash fargo slash rules and there you find the read me with all the instructions so the first thing actually that you do is That you fork the the project on github and then you move on But it's everything like written here in the contribution guideline. So it's quite easy So as you see we decided to use github for contributing to rules and for working For working on the triple 8 port because the pull request never thing makes it Be easier for us to to innovate and work work faster like in branches than with the patch workflow For later, we are not yet sure about whether we will keep github get up or move back to the triple org issue queue So that's undecided yet, but for now interpolate development only is on github So let's have a closer look at the the API's of rules in in triple 8 and let's compare them to triple 7 So when you have some some module that integrates already with triple 7 you get an idea on how to do that the same in in triple 8 So basically always when you want to integrate your module with rules The first thing to do that you need to do is really describe the data so that Rules is able to to know about the data that you're working with like when you have a module that Exposes and your entity type rules needs to know about it needs to know about the properties and other things We can deal with that so in triple 7 basically what you had to do for it is like mostly you had to provide the hook entity property information by the entity entity by module and then rules worked with that and In some certain situation you could also provide a new data type But basically that's like the fundamental thing and once you do that all the generic actions and conditions of the rules module like the Data comparisons that the data value are also the entity actions and conditions then are automatically work based upon that So that's really the the first thing to do and in in Drupal 8 Fortunately, there's a new API the type data API which we managed to get into core Which is really the crucial thing that we are building up. So What's nice about it? It's basically that it's all in core and once you follow the things that call already has You basically Asset so to give you a short overview about what it is and then get an idea so the type data API basically is Consistent way of interacting with any data based up in your metadata. So it allows you to Deal with entities and data in a generic fashion. So basically it works up in type system that's defined in PHP So it comes with some very basic primitive types like string integer float and so on Then it also defines something we call like complex data type It's basically a complex type is some data structure with some named properties in it And then it also has the notion of lists the lists are basically multiple values of some data type So this is an overview of all the data types that are already in Drupal 8 core So as mentioned, they're all the basic things that string integer But there are also some some more special things like timestamp email That's all already in core and you can just use it also with the rules module when you describe your data and The same way doesn't like automatic types for entities like entity node So in Drupal 7 that the type work for node was just node in Drupal 8 It's always entity color node entity color entity type. So that's a little change but it also makes sure there can't be any namespace collisions and Similarly, we also have automatic data types for every field type test to find in a system It's just a field item column field type name. So like the text field type would be field item column text So this is an example on how you provide a new data type in case you really need that like Mostly, I think you you are good with the defined data types But follow you to get an idea like a data type in Drupal 8 is just a plug-in So you can also extend and add your own special data types like if you would you could add Floats that's just as of a certain ranges as a separate data type and basically what as this is a float It's a primitive so it extends primitive base what also makes sure it's extending like primitive interface it's all based up interfaces and Really reusable This is another example for implementing a field type As mentioned, there's the notion of complex data. So field items are complex data because they contain multiple properties So if you think of like the link field it contains like the example here It contains the URL and when you implement the field type You just define the properties that your your field items gonna contain you have to do that for implementing the field type And that's the same information that rules is going to make use of a solar So to sum it up to for describing Data to rules in Drupal 8 basically you just need to implement the core by follow that type data API and There are also some some hooks you can use in addition to like what you have seen There are some like hooks for defining code fields But basically if you use the configurable field, it's known to rules banding on its own if you implement the field type It's known Yeah, so that's really the good news in that direction like everything you're doing in Drupal 8 core with your content entities Automatically works with rules as well. There's no extra work needed in that regard anymore Yeah, so Glossy will explain how to write conditioned action against and some events exactly so For rules in Drupal 8 and the interesting parts of course for the contribute developers like you you're writing your custom module How do you integrate with rules? Of course with the building blocks that itself the engine uses and that are conditions actions and events and If you look at that what are we doing in Drupal 8 rules what everybody is doing in Drupal 8 and that is using plugins So I guess you heard this already a lot at this conference So we saw the plug-in system right now in Fargo explain type data You basically probably saw it in some other session already And this is the go-to API to specify things of a certain type like you specify actions that are that fulfill some interface This is done by the plug-in system. This is completely object oriented. It's not a very complex system You basically have a manager that creates the plug-in instances for you And you have some way of discoverability so that you place your class somewhere in the file system in your module And then it gets found and then it's get into this plug-in system for this type Most of the time this is done via annotations annotations are special comments on PHP classes we already saw that in on the type type data example that Fargo gave and where you leave the plug-in ID some label or other definitions that this plug-in type brings and By putting in a special location in some plug-in folder for example in a contra module It gets recognized by the system and then it's available for use in the system So in this in this case who's for example can build a select box where you select the action It just asks the action manager give me all actions that any module defines and then people can select it in the UI Yeah already told you about discoverability this works by just putting that class in a specific place And there are also derivatives of plug-ins. So for example, you have the entity save action And in the user interface, it's confusing to have entity save and users don't know what does that mean So you want to expose that for any entity type so you can create virtual plug-ins So to say where you have That action for node saving for user saving for taxonomy term saving and then you can put it in that group in a node group For example, although the code base behind it is just one plug-in But it it poses as multiple plug-ins in the system and that's really just Drupal core features Rules is just leveraging that and it's really powerful and you will see that everywhere in Drupal core So plug-ins are entity types of plug-in data types of plug-ins Views and users plug-ins basically every module in Drupal 8 will use plug-ins So I guess the first thing you will learn about Drupal 8 is how to use plug-ins really So providing conditions how we do that in Drupal 7 we had this hook hook rules condition info and basically in there you had an array which would specify the name of the condition and what parameter it takes and The callbacks which should be used and the replacement for that in Drupal 8 is implementing a condition plug-in Let's look at the code how that looks like so Yeah laser point is here This is basically the annotation Which I was talking about we already saw that it's this ad character with some plug-in name in this case It's just a core condition plug-in type and there we describe all the stuff that is statically available like the ID the label and whatever Yeah, you can also leave other commands up here So it's not really complicated to do and for simple conditions like this condition for nodes we just have to implement the evaluate method and What we try to check here if the node is sticky which means it gets placed on the front page for example in some special place So we get the node from context. This is also one important concept of Drupal 8 and rules specifically That any any context and a parameter this action needs gets set on this object before the evaluate method is invoked And then we can conveniently access it here and then do something and we just call the is sticky method in this case And then return true or false and that's basically it for for implementing a condition So this is really a convenient API for any country module It's it's really fast they've written and it's just a class and then you basically are set So how do we provide actions? so the mirror of the conditions API is the actions API and that has to have the hook action info in Drupal 7 same principle you specify an array with all your action that you want to define and Actions look basically the same in Drupal 8. It's one plug-in class. You put it under the plug-in slash rules action folder in your contributed module directory rules itself also Provides this action. So this code example is taken from the rules module itself So rules provides the engine to run all this action and condition system But it also provides the most common actions for core for example in this case deleting an entity is a common task rules implements that itself and Again, it's just a simple interface which specify that the plug-in has to implement the execute method and Same system here. We have some context where you pull the entity from and then we just call delete on it. So Any action or the condition plugins that you will see in Drupal 8 will be fairly simple They just call some other API that is generally available and that's how they integrate with rules itself Yeah, you can see some other stuff in your notation like this stuff is translatable So when you have them your your site in Italian for example the annotation reader reads that and Translates it for you. So you can even have Italian labels in the rules UI This is also just basic principle from the plug-in system in Drupal 8 that we can leverage here Providing events. This is a bit different events are also plugins in Drupal 8, but they use the Symphony event system. So what we had in Drupal 7 was and hook hook rules event info which specified one array with the stuff in it same like the other hooks In Drupal 8 we have Symphony events plus some YAML files where I'll specify metadata So in order so that rules knows which events are available so that you can select again from the UI We have to specify this in a YAML file rules itself does that and the YAML files looks like this So for example, we want to Register the user login event with rules. So we create this YAML file. This is also part of of rules itself Give it a label and we want to show and make it show up on a specific category And it has some context and that is exactly the account That has just logged in The type information is important. It says that this is a user object So that rules knows what fields are available on the user and can make use of that So this is the first part. So now rules knows about this event. How is this event actually invoked? And it works like this This is an example Of rules itself it implements hook user login. So in Drupal 8 we still have hooks and we have events Unfortunately, it was not possible in a Drupal development cycle to eliminate all hooks and convert everything to events so we will have to deal with both cases in Drupal 8 and User login is one example of that. So what rules does in this case, it throws its own event The first critical part here is that we create our own event class. So this is a very basic class It doesn't do anything. It's just extends the symphony generic event class And passes in the account object so that we can later pull it out and pass it on to rules And then we just get the event dispatcher, which is a Drupal core service So we just get this event dispatching service and then invoke it with some special name which is a constant on our event and Our event object that we created above and that's basically it and then rules will catch this event and then Look up its configuration. Do we have a rule configured for this event and then invoke it? So for you as a module developer, it's really simple. It's You just create this event class passing all the context information that you specified in a YAML file And then you're basically done rules will handle the execution for you It's similar as in Drupal 7 where you called rules invoke event Just here you dispatch it through the event dispatching service So the great example at a great advantage of this in Drupal 8 is that you are throwing that event not only for rules So rules can listen to that event and invoke the The rules but are also contraped modules that just implement symphony events symphony event subscribers can also react to that So actually this is not a rule specific integration that you are doing when you are invoking symphony events like this This is how the event system is supposed to work So when you write your Drupal 8 contraped modules You should always use events because hooks are basically Deplicated there might be some edge use cases where they are useful But anytime you want to ask other modules to give their input you would invoke invent and then rules Automatically has integration for that. You just have to specify the YAML file that it's known to rules So Fargo will tell you a little bit about context next Yeah, so as you have seen For conditions actions and events context is everywhere. So I want to shortly like tell you how to work with context in general So first of any define a new plug-in like a new conditional action You really need to find also the context that the plug-in needs to work with and The way you do this as class already mentioned is a way to annotation You just have like a context key in the annotation and there you basically fill all the information about the Contextual parameters that you need so in that example, it's like an entity delete action It needs the entity that should be deleted so that the entity is the needed context for the for the action to work So you basically Have to provide a name for the context here So the name is entity then you use the context definition class to to describe the The context that is needed in a little bit closer We had a most important part is actually the data type in this case is here It's also entity as as shown before like there's a generic data type entity So you can specify that here. So who's it knows it's a generic some kind of entity that's needed here So it will work with nodes users and so on Then in addition, of course, there are some some other keys label and descriptions you you should specify at least But there are also some additional other keys similar to as it worked in in triple seven with that department area definition So really same concept, but it's just in the in the annotation So once you Described all the needed context here for a plug-in the next step really of course when you need to work with the context somehow So how you use the context in the plug-in is actually Some a little bit special here in that situation for actions We made it a little bit easier and that you just have to implement a Method called to execute and it will automatically get all the defined context past So as you know it from rules in to put seven just in the same order as you defines that the contextual parameters You'll get it then just past So in that example, we had an entity context So the same way we just put the entity as a parameter to the do execute method We'll get past to the method and that's it Another example here is the fetch entity by a D action which actually not only Works with some context, but it also provides contact back to two rules Like the entity is loaded is provided back to rule so that sub to rule so that subsequent actions can also work with that Entity and the way you do that is basically that you use the set provided value method on the plug-in to just set the Entity that you want to provide back Similarly, I like the the set provided value method There's also like get context value method for getting context if you don't want to like use the notation here Like the context that it's past here. It's also available via get context value and The context name so that would be an alternative way of doing it as well Yeah, and finally Passing context to the plug-in When you like want to use a plug-in that needs context Somehow the contact needs to be provided to it in the case of rules It's rules doing it so you don't need to take care of it But an example given when you want to test your your conditional action plug-in. You can also do that So this is an example taking out of the test actually It just shows like when you already have instantiated your condition plug-in So it's this condition here. You can just call the method get a set context value to set some context on the plug-in So the first parameter has to be the context name again and second parameter is just the value for the context So you call that method for each of the context that's Required by the plug-in and that's it afterwards. You can execute the plug-in So let's have a look at configuration Yeah, so now we have configured this nice rules With the rules module and of course we want to export them So how do we store configuration to blade? Of course with the config system which writes everything to Yammer files Which is really useful. So if you remember Drupal 7 and working has Invented this amazing Jason API with the entity API exports So basically it's the same in Drupal 8 although it's a sim a similar a simpler format Yammer. It's it's more flexible and easier to read and Yeah, we had the export it was in Drupal 7 and Rules was using basically on its plug-in classes and the methods to to Serialize this this configuration, but in Drupal 8. It's a bit more simple We just generate a dump array of output and then the configuration system will Write it down to disk into Yammer files for us and we also specify a Schema for that so that everything is translatable in in that configuration export This is all just core features that rules can leverage the same features the same Yammer export are used by fuses For example by other configuration things in in Drupal 8 it's called a Configuration entity in Drupal 8 because it's similar to entities, but they are not stored in the database But rather in Yammer files. I mean they are stored in the database, but they are configuration so it's a bit confusing and What we have right now in in Drupal 8 is we have basically two things two different Config entities that we are storing one are reaction rule and the other are components So components are is just the stuff that you had in Drupal 7 which had no event attached to it But you still can export it and reuse it for whatever purpose and reaction rules are of course that configuration entities that are configured to trigger when an event is fired and Yeah, of course you get all the nice features from from CMI that you can Write those things to disk commit it to a git repository Whenever you change your rule you will see that in your git if you can commit that again It makes it really easy to deploy and then synchronize a configuration into your production site So you don't have to mess around with configuring rules on your production side same within in Drupal 7 You would just configure it on your development side once you're done And you're sure that the rule works you export it and then you deploy it to a production site It's kind of like the features module in in Drupal 7 But yeah, it's not 100% comparable, but it there will be workflows in in Drupal 8 that support this There can also be default configuration Which means when you install your module a rule is automatically created and also activated So we had it basically in Drupal 7 and it's even easier into plate Yeah, so we had this hook which had which had contained PHP code where it could Use the entity API exportables to get your rules or you could use the rules API to configure a rule and then return it And what we have in in Drupal 8 as I said are this YAML files and you can easily spot them by the by their extension It's rules.reaction.yaml or rules.component.yaml with the machine name in them So it's easy to find them. You can grab for them. It makes makes it really easy And this is what an exported rule looks like. It's just basic YAML So YAML does not have any any special tags. It's just a key value system Basically, it can be nested with indentation or with this brackets a Lot of the stuff like the labels here. This is Potentially translatable since this is already just with the configuration schema and Yeah, if you take a look through this we also see that we have the actions in this configured rules and the condition as well What context that they have on how the message for example for this Showing a message on the side We are using just the mail of the user in this example and the user comes from the context of this Context that is specified on the rule So even the configuration that we export is very readable and easy to maintain Yeah, back to you. I think is that your part All right, I think I do that So when we're working with config entities We just load them from the configuration storage by some machine name Out of that we generate generate the rules expression So we call this the rules expressions that our reaction rules for examples or rules components that are different kind of expressions and Out of the config entities using the configuration that we have stored here The expression object gets instantiated and then we before we execute it We set the context in this case It's example It's important that this rule receives a user object as we saw we want to show something on the site So we need this this context for this rule to work and then we just execute it And it's basically all the API you need whenever you want to execute custom rules in your module Whatever you're doing like triple commerce is a potential candidate for executing rules like this They will use a pattern like this So back to yourself for UI topics Yes, so on the previous presentations, we always said there's no UI yet Now we can say there are some stops for the UI already. So what really got me excited Was a pull request that Klausie created where you can already Create an action and start creating a condition and it would already expose all the conditions that are there And the list is quite big because based on the derivatives concept that we have mentioned You get actions for creating all the different entity types updating them deleting them and so forth So we can actually see the fruits of all the contribution work that that we have received so far, which is cool There is a meta issue Where we basically split down the workers that has to be made But so far there's not much available besides listing a list of rules components and creating stops for them But you cannot really edit you cannot really create actions conditions Within them at the moment But that can change really quickly if we get your help or if we get more funding Would be awesome to make progress Now with the UI as all the underlying API's as you have seen are already maturing pretty far Yes, so what qualifies as contribution as we are here at this conference together Talking about open source about Drupal specifically I Kind of felt like it's it's interesting to see all the different ways that we can collaborate It's not just about being a developer being a coder, which is definitely appreciated if you have continuous Resources that you want to invest for example in helping us out with the rules module Development is definitely highly appreciated But it's also super easy to just convince your boss or any anybody else Donate money to the initiative. It's definitely invested in in a good way in a reusable way We try to Really do a good job with the with the initiative There's a lot of other ways you can help out writing documentation Steve Perkis wrote a lot of documentation and fooby So there's already some rules Documentation available for developers, but along the way we'll need more help there And in general promoting the initiative Then yeah that that can all help For us the main focus now is Getting more funding so that we can free up more resources from the main developers because rules is a really complex topic and we cannot just Outsource all of the hard problems because Fargo and clausie have years of experience and we kind of kind of makes most sense to efficiently let them work on it So yeah getting the funding Up to speed again Is the main focus point and then sprinting because there's so many of you who might be willing to play around with the code to To get a bit of a feel of the apis to maybe Port your contributed modules so tomorrow We'll have a bath around lunch Where we basically give an introduction on a more personal level where we can also have more of a discussion on How the the next steps on the roadmap looked like how you can help us or how What you can expect from the initiative over the next month So definitely come to the bath at 11 45 tomorrow wednesday room 129 and on fridays in the whole Contribution sprints we'll have At least one rules table where we can all sit together and work on tickets. There's There's contributed tasks from very easy to very advanced. For example, boy on sivanovich wrote the derivative tests During a conference which were pretty advanced People have already started writing integrations for the flag module People have written a lot of small actions condition plugins Some people have already started working on a Yeah, and like logger logging system integrations There's a lot of nice ideas and we we definitely appreciate all of the contributions So yeah Friday is a good day to sprint with us on the d8 rules website. You can also see some learning resources presentation videos And there's a link to find contributor tasks as mentioned. There's tasks for beginners. There's tasks for advanced people So definitely check that out um And with that we happy to take your questions and thank you very much So if you have any questions, there's a microphone on the side. I don't think at that side so that it's in the recording Or we can just repeat the question Anyone porting a module at the moment Does it have rules integration? Okay So first of the the question is What about the debugging so like in Drupal 7 it's quite cumbersome to debug the rules and is there any solution to this? and so the answer is That there like isn't no like planning that we like directly improved the debugging capabilities of rules but actually We there has already been worked to to integrate like rules with the new symphony How's it called the debugger console? Web web profiler. Yeah, they're like with web profiler to integrate with it So we'll at least make sure that like all the the profiling information everything and the rules debugging will integrate with that But on top of that what we Would like to experiment with is really like to to write rules down as sphp files What what I think would be the the best way to also ease debugging So basically the idea is that you Configure your your rules as regular but like just for also increasing performance Like when the the rules are done they are written to disk as a regular psp file And then you could use a regular psp debugger also to to debug the rules What what I think would be the the best developing experience Okay, any any further questions Otherwise you can also ask tomorrow at our barf. I think it's at 12 Do you know the room? I think we had the room. Yeah, you can find the room number on our website And thank you again