Plone 6 Beyond 2022
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Number of Parts | 44 | |
| Author | ||
| Contributors | ||
| License | CC Attribution 3.0 Germany: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/60223 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language | ||
| Production Place | Namur, Belgium |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
Plone Conference 202240 / 44
10
14
22
23
26
27
40
00:00
Turtle graphicsLTI system theoryPRINCE2Multiplication signLattice (order)Data miningNumberInformationHorizonComputer animationLecture/Conference
00:44
Term (mathematics)State of matterBlock (periodic table)Lecture/ConferenceMeeting/InterviewXML
01:24
Alpha (investment)Phase transitionRevision controlLecture/ConferenceMeeting/Interview
02:09
Alpha (investment)State transition systemFront and back endsTerm (mathematics)Right angleMathematicsInformation securitySinc functionLecture/ConferenceMeeting/InterviewDiagram
03:05
1 (number)Tablet computerTouchscreenArithmetic meanDemo (music)Programmable read-only memoryLecture/Conference
03:55
State transition systemLine (geometry)Branch (computer science)Lecture/ConferenceMeeting/InterviewDiagram
04:33
Moment (mathematics)Event horizonStability theoryRight angleBranch (computer science)Lecture/Conference
05:13
Revision controlRight angleBranch (computer science)MathematicsStability theoryServer (computing)Table (information)State transition systemControl flowLecture/Conference
06:03
Revision controlPoint (geometry)Multiplication signRevision controlRight angleBitLecture/ConferenceComputer animation
06:47
Core dumpWindows RegistryAsynchronous Transfer ModeProxy serverServer (computing)VolumenvisualisierungText editorRoutingBit rate1 (number)Windows RegistryCore dumpRight angleConfiguration spaceConnectivity (graph theory)Module (mathematics)Acoustic shadowMultiplication signFunction (mathematics)Endliche ModelltheorieComputer animation
07:37
Windows RegistryComputer configurationConnectivity (graph theory)Point (geometry)Portable communications deviceProxy serverReal numberAsynchronous Transfer ModeLie groupGoodness of fitProjective planeLecture/ConferenceMeeting/Interview
08:26
Core dumpServer (computing)VolumenvisualisierungWindows RegistryAsynchronous Transfer ModeProxy serverRoutingText editorAsynchronous Transfer ModeProxy serverMultiplication signProduct (business)BuildingTraverse (surveying)Medical imagingIntegrated development environmentVariable (mathematics)Arithmetic meanServer (computing)Computer animationLecture/Conference
09:28
Core dumpWindows RegistryProxy serverAsynchronous Transfer ModeVolumenvisualisierungServer (computing)RoutingText editorText editor1 (number)BuildingBlock (periodic table)Software frameworkComputer animationLecture/Conference
10:09
Process (computing)Server (computing)ImplementationArithmetic meanMaizeLimit (category theory)Block (periodic table)Lecture/ConferenceMeeting/Interview
11:02
BitSoftware developerRight angleScripting languageOracleArithmetic meanSpeech synthesisPhysical systemLecture/ConferenceMeeting/Interview
11:59
Artistic renderingServer (computing)RoutingState of matterWordProcess (computing)Lecture/ConferenceMeeting/InterviewComputer animation
12:40
RoutingArtistic renderingServer (computing)State of matterState of matterArtistic renderingBuildingLevel (video gaming)Connectivity (graph theory)Group actionPerformance appraisalBitLecture/ConferenceComputer animationMeeting/Interview
13:21
Server (computing)Revision controlMoore's lawSuspension (chemistry)BitMereologyConnectivity (graph theory)Computer architectureArtistic renderingTask (computing)Client (computing)Analytic continuationComputer animationLecture/ConferenceMeeting/Interview
14:31
Client (computing)Connectivity (graph theory)Computer architectureSuspension (chemistry)Line (geometry)Server (computing)VolumenvisualisierungMultiplication signProcess (computing)Shooting methodHypermediaLecture/ConferenceMeeting/Interview
15:28
Server (computing)Link (knot theory)Observational studyStreaming mediaBitClient (computing)Hasse diagramConnectivity (graph theory)Artistic renderingLecture/Conference
16:27
Server (computing)Server (computing)Connectivity (graph theory)CodeClient (computing)Physical systemComputer animationLecture/ConferenceMeeting/Interview
17:23
Server (computing)RoutingRouter (computing)Library (computing)Single-precision floating-point formatRevision controlRouter (computing)BitLimit (category theory)IRIS-TPoint (geometry)Connected spaceMusical ensembleLecture/ConferenceMeeting/InterviewComputer animation
18:26
Library (computing)Router (computing)Connected spaceSet (mathematics)Connectivity (graph theory)Server (computing)Point (geometry)Lecture/ConferenceMeeting/Interview
19:27
RoutingRouter (computing)Router (computing)Library (computing)InformationData storage deviceRoutingSocial classClique-widthAirfoilUniform resource locatorFunctional (mathematics)Query languageConnected spaceConnectivity (graph theory)Point (geometry)Wave packetLecture/ConferenceComputer animationMeeting/Interview
20:53
RoutingBootingRouter (computing)Router (computing)Library (computing)RoutingBootingFitness functionLecture/ConferenceComputer animation
21:31
Plane (geometry)DemosceneRoutingSynchronizationMathematicsSoftwareFlash memoryContent (media)Lecture/ConferenceMeeting/Interview
22:17
RoutingBootingRouter (computing)Computer configurationMultiplication signRoutingMathematicsRouter (computing)Right angleLecture/ConferenceMeeting/InterviewComputer animation
22:56
RoutingBootingRouter (computing)CASE <Informatik>Router (computing)Data storage deviceLink (knot theory)Connected spaceMathematicsBitBit rateDemosceneComputer animationLecture/ConferenceMeeting/Interview
23:43
Artistic renderingServer (computing)ArchitectureArtistic renderingServer (computing)Computer architectureBitRevision controlCore dumpBit rateLecture/ConferenceComputer animation
24:27
Artistic renderingServer (computing)ArchitectureQuery languageComputer configurationRoutingMultiplication signComputer architectureSuspension (chemistry)State of matterReading (process)MathematicsMereologyGame theoryProof theoryComputer animationLecture/Conference
25:14
State of matterServer (computing)Configuration spaceLatent heatArchitectureState of matterProgramming paradigmLibrary (computing)Direction (geometry)Mobile appServer (computing)Right angleComputer animationLecture/ConferenceMeeting/Interview
25:51
State of matterLibrary (computing)Server (computing)Limit (category theory)Reduction of orderMultiplication signQuery languageFactory (trading post)Lecture/ConferenceMeeting/Interview
26:58
Server (computing)Web pageState of matter2 (number)MathematicsLevel (video gaming)Query languageMultiplication signTrailComputer animationLecture/Conference
27:46
Computer architectureClient (computing)Query languageSuspension (chemistry)Normal (geometry)Logic gateRevision controlResultantLecture/Conference
28:28
Front and back endsText editorRevision controlConnectivity (graph theory)Wave packetSoftware frameworkOntologyPoint (geometry)Data storage deviceWordComputer animationLecture/ConferenceMeeting/Interview
29:25
Data storage deviceConnectivity (graph theory)State of matterServer (computing)Software frameworkQuery languageLecture/ConferenceMeeting/Interview
30:23
User interfaceText editorProcess (computing)Core dumpProjective planeLibrary (computing)Right angleCartesian coordinate systemMultiplication signBuildingBoilerplate (text)CASE <Informatik>CompilerPoisson-KlammerPhysical systemLecture/ConferenceMeeting/InterviewComputer animation
31:21
Classical physicsBoilerplate (text)Compilation albumData managementRight angleError messagePoint (geometry)Multiplication signRevision controlLecture/ConferenceMeeting/Interview
32:19
Single sign-onRevision controlData storage deviceProjective planeComputer architecture1 (number)Arithmetic meanMeeting/Interview
32:56
ArchitectureBootstrap aggregating1 (number)Physical systemDemosceneFlow separationTrailComputer animationLecture/ConferenceMeeting/Interview
33:54
Flow separationCross-site scriptingPhysical systemValue-added networkSubsetForm (programming)Flow separationPhysical systemLie groupStructural loadDampingForestState of matterSoftware frameworkComputer animationLecture/ConferenceMeeting/Interview
34:50
Flow separationPhysical systemCross-site scriptingSoftware frameworkConnectivity (graph theory)Fiber bundleRight angleDirection (geometry)LeakMedical imagingPhysical systemLecture/ConferenceMeeting/InterviewComputer animation
35:45
Content management systemDirection (geometry)LeakPhysical systemPoint (geometry)Multiplication signBlock (periodic table)Lecture/ConferenceMeeting/InterviewComputer animation
36:27
Plane (geometry)Block (periodic table)Point (geometry)Computer architectureChainControl flowTouchscreenLecture/ConferenceMeeting/Interview
37:09
ImplementationPhysical systemCloningComputer architectureMultiplication signVideo gameCanadian Mathematical SocietyState of matterTouchscreenBlock (periodic table)Group actionBlogComputer animationLecture/ConferenceMeeting/Interview
37:56
ImplementationPhysical systemGroup actionBitConnectivity (graph theory)Point (geometry)Multiplication signLecture/ConferenceMeeting/InterviewComputer animation
38:50
Electronic mailing listPlane (geometry)Web pageBlock (periodic table)PortletWebsiteMixed realityPortletTesselationPoint (geometry)WhiteboardVideoconferencingMultiplication signLecture/ConferenceComputer animation
39:39
TesselationRandomizationMultiplication signBitPortletData storage deviceCuboidKey (cryptography)Physical lawData miningAtomic numberBlock (periodic table)Lecture/ConferenceMeeting/Interview
40:21
TrigonometryWeb pageBlock (periodic table)PortletContent (media)Maxima and minimaAtomic numberMultiplication signSign (mathematics)FeedbackGoodness of fitInheritance (object-oriented programming)Lecture/ConferenceMeeting/InterviewComputer animation
41:10
Form (programming)Library (computing)Block (periodic table)GUI widgetFinitary relationControl flowDrop (liquid)Drag (physics)Goodness of fitRandomizationRow (database)1 (number)Electronic mailing listSpring (hydrology)Block (periodic table)Group actionProxy serverBitLecture/ConferenceComputer animationMeeting/Interview
41:58
CAN busBlock (periodic table)GUI widgetForm (programming)Library (computing)Drag (physics)Drop (liquid)Control flowFinitary relationRow (database)Block (periodic table)AreaBlogSystem callDrop (liquid)Physical systemDrag (physics)Ocean currentContent (media)Meeting/InterviewComputer animation
42:37
Revision controlTheory of relativityField (computer science)Group actionProof theoryHyperlinkGame theoryLecture/ConferenceMeeting/Interview
43:22
Field (computer science)ResultantGUI widgetComputerBlock (periodic table)Point (geometry)Configuration spaceContext awarenessForm (programming)Right angleLecture/ConferenceMeeting/Interview
44:00
Block (periodic table)Drop (liquid)Drag (physics)Finitary relationControl flowGUI widgetForm (programming)Library (computing)GUI widgetContext awarenessBlock (periodic table)Source codeValidity (statistics)Point (geometry)Form (programming)Electric generatorComputer animationLecture/ConferenceMeeting/Interview
44:41
Default (computer science)Block (periodic table)Point (geometry)Goodness of fitSet (mathematics)Library (computing)Numbering schemeElectric generatorElectronic mailing listFront and back endsWeb browserBitFunctional (mathematics)Object (grammar)Lecture/ConferenceMeeting/Interview
45:32
Front and back endsStack (abstract data type)Metropolitan area networkValidity (statistics)Point (geometry)View (database)CASE <Informatik>Physical lawArithmetic meanProof theoryFront and back endsMultiplication signComputer animationMeeting/Interview
46:15
Front and back endsMultiplication signoutputFormal languageRight angleLecture/Conference
46:58
Context awarenessFormal languageRight angleClassical physicsLecture/ConferenceMeeting/Interview
48:10
Lecture/ConferenceComputer animation
Transcript: English(auto-generated)
00:01
Thank you very much for your time. We have Victor Fernandez de Alba. Thanks for attending my talk. My initial goal for this talk is to present to you a
00:24
number of topics that had information on the horizon. During Volto team meetings, things that we have in mind, I mean, especially the Volto team, but also that I've been
00:40
talking here and there with people, also in our company, and So I wanted also, I wanted to transmit to you, I mean, to communicate to you and that you also know what's our, the things that moved us, that we think that should be those things that we
01:02
should address in the next years or in short term also, if possible. So that's the state of Volto, Plone 6 Volto and how it relates to the Plone 6 final
01:26
release that is upcoming hopefully soon in the next weeks, months, yeah. Most probably weeks, then months, but yeah. So this is the idea. So Plone 6 LTS will be matched with the Volto
01:47
6 final because now we are in the alpha phase still, we are polishing and we want to add a few more features to that that are in the makings. Hopefully they will be merged because they are almost really
02:03
during the sprint. But yeah, this is an important thing that everybody knows, right, so Plone 6 final will ship with Volto 16. Volto 16 will be the LTS and it will have the same
02:21
treatment as the backend, right, because at the end they are the same thing and we want to treat it as the same thing, so Volto 16 will be LTS. Which means that we will have this long-term support that we are planning also for the backend.
02:40
And let me show you how the releases have been in the last year. So this is a quick look at Volto 16, yeah, quick look with Volto 14 back in December last year. Then we moved quickly to Volto 15 because we had a breaking change with a security issue that we discovered.
03:01
We fixed it right away. We had Volto 15 quickly released. Then we have been working in Volto 16 since June approximately when the Bonn sprint, the Bitumen sprint happened.
03:21
We introduced a couple of blocking features that we wanted Plone 6 to have. Amongst the most important ones probably will be the adoption of Slate, which is already there. So if you go and try already Volto 16 alpha, the last one is 42 still. The last one is 42 still that we released before coming to
03:41
the conference. It's there. You can try it out. It's going to be almost final. It's the one that is in 6.demo.plone.org. Try it out, play with it. I mean, it's great. Then, yeah, how these releases are going to happen.
04:02
And this is the last thing that I will say about releases, but I wanted also you to know how it's going to be. So as I said, we're going to have this Volto 16 release that will be LTS, so it will go into the future until we decide that another LTS will be,
04:22
should be released. And then we will have what we more or less have now, or we had in the past. So we will have a line, a branch that we will call Volto stable, that is what we all know, the people that already worked in Volto.
04:40
So we'll have this stable branch, and after release of Volto 16, we will start working on Volto 17 right away. Then we will also create, when the moment comes, I mean, that two events won't happen one after another, right. I mean, at the beginning Volto 16 will be stable,
05:04
right, and then once Volto 17 get this stable label, then it will go where it is here in the chart, then we will create Volto 18 alpha, and this will be the canary branch that we already this, as you all know, right, from the last
05:23
years, this living on the edge version that we have with Volto, right. And this will be more or less the landscape that we will have in Volto releases. Of course, everything that will happen in stable
05:41
feature-wise will be back ported to LTS. LTS and LTS, and LTS and LTS, and LTS, and LTS and LTS, and LTS, and LTS, and LTS, and the same for canary, right. So only breaking will go into canaries, features will be ported into 17, well, into this
06:00
stable branch that you can get more or less a grasp on it. Then, yeah, how this will match with 6. So, yeah, this is only an example.
06:21
It's not something that is going to be true right away, but maybe Volto 18 is going to be blown 6.1, and we will try to do these matching releases for everybody knows that, yeah, 6.1 goes and works well with 18, only as an example,
06:44
right. Okay, let's go, let's do a little bit of exercise. So we have some core features identified in Volto, right. These are the ones, though, first the
07:02
configuration registry, which I think that is the real kernel, so the heart of Volto, and we have been polishing it over time and, yeah, I mean, we have a lot of work to do, and we have now a good story there. Then we have the shadowing and the
07:22
new component registry, which allows us to override existing modules and work in a very flexible way, so say, you know, I want this module, but I want to change a small thing, and we even have now the ability not only going with the shadow option, but also using the component
07:46
have a lot of work to do over and over and over and over, that the component is being full for the registry and it's being used in my code at some point. We think also that this is very powerful and it's working, it has been working through the last years and this is also very
08:01
important in Volto. Then we have the add-ons architecture, something that we built and we pour add-ons architecture, something that you can do in an add-on, anything literally that you were
08:21
doing before using a project, so you can have this portability everywhere, you can have add-ons that are themes and all those kind of things, and we think that it's very, very solid, very, very good. Then we have the seamless mode and internal proxy that we are also very
08:46
We are very proud of that and we managed to get it right. It's working well. We have it in production. The new traversal is amazing. Thanks, Jens, for it. Yeah. Now, we seem like we also have builds that are no longer dependent into build
09:02
time and environment variables. We can do a build, it runs, and can be configured on the that, and it can fly everywhere. That also improved our Docker container images. Yeah, so I think that this is also a solid one.
09:22
Then we have the routing, which is important, data fetching, the server-side rendering, the theming and the pastanaga editor finally. Yeah, I went quick through these last ones This, the identifying this came when I tried to do
09:47
an exercise. So I tried to get one of the next big kids on the block, which is Next.js, and I said, okay, what if we want now to build Volto in Next.js?
10:09
It's owned by Vercel now, and everybody in the industry of JavaScript is hiring, Vercel is hiring everybody in the community.
10:22
And it's a very nice tool for the job. It has an extremely amazing server that does a lot of things, although it has all the limitations, but I thought, okay, if I had to implement Volto in Next.js, what will need, what I will need to get from Volto
10:42
extract it and port it into Next.js. And all these kind of things needs to be there, right? The same with remix. I don't know if anybody has thought, it's the other new kid on the block, remix, and the remix guy, oh, a lot of buzz in the community also, we will have to do the same.
11:03
remix, what will happen? The thing is that after identifying those, we also realise that we should continually curate these features bit by bit,
11:21
because we want it to, we want them to be also still having high quality and still being them is maximum, right? And what we have, we have this ever-changing React ecosystem that pushes,
11:42
but not pushes, but I mean it's something here that like a little devil that say, hey, you know what, this big thingy, and it works well, and the developer experience is so great, maybe you should implement it, and yeah, you also always have
12:03
So what's ahead? So there are some topics that this devil is telling you here that you should do that, or you should try, maybe it's better, maybe it works better. So I want to go also then, right? Again, it's nothing that Balto doesn't work well
12:23
now, or something that we should really do, because if not, Balto is going to die. No, it's React and that I wanted also to explain to you which are. So yeah, I tried to list them here.
12:41
First one is React 18. React 18 is out, I don't know how many, how much is out already, like six months, whatever. So yeah, a lot of us are around React 18. I will talk a little
13:03
React 18 is about state handling, reusing components and build modernisation, and I want to go through this list and explain you a little bit how, what we have to at least take a look, evaluate and if it's worth or not, and maybe take action.
13:24
So first about React, what happened in React lately. So the version that they say that is going to be the concurrent version, so React 18, they promised, and I
13:42
say they promised, because they still haven't fulfilled the full promise, so they are almost there, but it's been years since they have been saying, yeah, yeah, we're almost there and everything, but the truth is that they still haven't delivered the most important part that Balto proposal could improve. I mean, I put really, really
14:05
take advantage of, but I will come to that in a bit. Then it has the next suspense SSR architecture, which is this promise land that you can also have suspense not only on the client, so yeah, because as
14:22
I said, React 18 promises that it's concurrent, so every component can not halt the rendering of other components, but it can say, hey, I will wait, and then the other component continues rendering and React 18 is able to do that through suspense, but
14:42
this happens on the client and it's the typical example that you see the component loading with a spinner, whatever, and all of a sudden when the component finish rendering, then the data pops and then the component shows. Not this, but they also
15:00
promise and they still didn't deliver the new suspense SSR architecture, so that is so that you know that we have the SSR rendering on the first request in Balto, so every time that you do the first request, the server side render shoots, which is the node process that is running with Balto.
15:20
So this is needed for COs and other social media, how it's called, the thing that appears when you paste the link somewhere, and then they, so with React 18 when it's completely there, we'll be able to do
15:41
that the same as now it does in the client, but on the server side rendering, so with streaming the server side rendering, it will be able to send the
16:07
chunk on the SSR and then the client get the chunk and put it when it belongs. And this is, I think this will be huge and we can have a huge advantage in Balto server side rendering.
16:25
The same for server components, server components are another technology that the React team has promised, it's not there, only POCs, yeah, here and there, but it's also very impressive, so the gist here is that you can have components that only
16:42
runs on the server. And why is this important, how we can get advantage of it, so for example, in data fetching, we can have a component that only runs on the server and then when the server, so the data fetch happens in the server and then only when it's ready, it will be sent to the client and
17:02
also the code is never on the client, so the server only takes care of getting the HTML, that this component has resolved, right. And this is also a quite powerful feature that I think that we really need to take advantage of. Again, the React itself landscape is ever
17:24
changing, it's continually improving, the React ecosystem is stronger than ever and yeah, with all these new tools that I told you, NetJS, remix, yeah, and others, and there are new tools and libraries literally again every single week, new
17:43
thingies, yay. So what about routing? We have a slight problem that we are currently stuck with React router 5 and this is because one
18:01
thing, because we are using two other libraries that depends on it. This is not a problem. I mean, no, we are not able to go to the latest shiny React router version. I mean React 5 works well, React 6 is fine. I mean React 5 has a little bit more features, but for all we need, our needs are covered, but we
18:21
have this small limitation that might be an issue in the future and we will have to take care of it at some point. These two libraries that depends on React router 5 are the async connect library.
18:46
This is the one that makes sure that when you request or you try to statically render the whole React 3, it gets in fact converted into HTML that is sent by the SSR server. It's the one that
19:01
makes sure that it waits for all the promises, all the data fetching that is happening in our components, because if not, if we were not waiting for them, then they will have empty components because, you know, async happening in node. And this is, yeah, a key component that we need
19:21
to take a look and to think about how to remove and replace it somehow in a fancy way. Then we have connected React router which is a library that is more a helper and we have been using it since the very beginning.
19:40
It's a library that gets the routes, the route info injected into the store so you can always go to the store and say hey, give me the route and give me the values because you have it always on the store. This one we can get rid of it easily.
20:01
In fact, I have a POC that, yeah, so we could remove it right away. Personally, I never used the store for accessing the routes information. What I do is to use React router directly to get
20:22
it, get the information from the thin air in functional components, you have use location and all the other helpers that React router has. For class component, you have the width router, width router, HOC, which is also same handy as read it from the store, so I think that it won't be
20:42
that of a problem to remove connected React query. But still, yeah, it's something that needs to be done. More about routing, routing libraries have improved a lot lately and that includes React router 6,
21:01
especially React router 6. 4, which I don't know if you know it, but the guys from React router are the same guys from remix. So in remix, they implemented a very nice way of doing route and something that they call
21:22
the data loaders. data, so do data fetching on routes. And this is very important and this is something that we were lacking in Volto scenes not very long away because we fixed that I think some months ago also.
21:44
And this could be very handy for one So since not that much ago in Volto you changed the route and the route was quickly changed to the next
22:03
route, but the data was lying a little bit or if your network was lying a little bit, then you saw a flash of content of the old content with the new one. And we don't want that. We want that the route change waits until the data is loaded, then
22:27
4 to get the appropriate data, right? React router 6. 4 can help with that. There are other options like time stack router, which is the same developer than
22:45
React query and others, so yeah, maybe worth to take a look as well. So this is something that we also take advantage of.
23:00
Remix and then JS could be that Remix is supporting more and more things to React router. So yeah, we can keep an eye on it, so just in case that we can take advantage as well. This also links with asynch connect because the fix
23:22
that I just told you for synchronizing the change that I just told you before, we implemented it as an asynch connect hack, so if we remove asynch connect, we're going to lose that, so we have to replace it with one of these things before. So yeah, a little bit of these features are kind of
23:42
intertwined, but yeah, I mean, all are more or less dependent on each other. More about server side rendering. We think that we need to modernize a little bit the architecture because it's a little bit, it got a little bit outdated
24:03
and simplify it. Removing asynch connect will help because it's obsolete, nobody maintains it, we have to, in fact, we have to adapt it. Now it's in core Volto and only works with React version 5.
24:21
I already have a POC because I was way to use the React router, use React query instead. In the SSR side, it works well. We'll have to do a little bit of adjustments, but at the end, I think that it will get a better and more flexible option.
24:43
We can also mix that with matching routes, so the same way that we are doing now asynch connect, we say no, I want that in this route, I get this route, I want it available on SSR time. I think we
25:02
can do almost the same. And then wait for the new suspense SSR architecture for React 18 will be also great to have it also in place. Then about global state handling, this is something that we can also tweak and improve a little bit.
25:21
The paradigm of global state handling in Redux itself, it's a little bit different, but the world is moving in other direction, so someone separate what is server state and the libraries that manage the
25:41
server state versus the app state and this is where Redux excels, right, so keeping the app state up to date so you can access, you can modify everything, but this server state, having it done by Redux, which is what we do now, started to be a
26:00
little bit cumbersome and we found its limitations and as I said, there are some libraries that now are doing exclusively server state and takes care of a lot of things for you and so you don't have to. The truth is that the 90 per cent of the time we are doing server state in Redux and I think we can
26:21
improve that. At least this, yeah, my personal feeling, yeah, other members of the Volto team also feel like me, we can, a lot of, still a lot of things to try, things to explore, to experiment, but I think that we should also explore this way of doing, yeah, data fetching at the
26:44
end in Volto. So for that, I think that React query is great in that regard, that is able to take care, yeah, and we'll go to the next one, so React query is able to take care of aborting requests, of caching, because in
27:05
fact React query, the nice thing that introduced is that the state, the server state is not only something that you save somewhere, but it's something that is cacheable, right, because it's what it is. I mean, I go to a page, then I navigate into
27:22
another page, but I go back to this page and now we are doing the request again, only five seconds after, most probably this initial page haven't changed, so we can, I mean, the idea of caching in server, in server state, I mean, it's quite
27:44
So with React query you can invalidate, you can, yeah, as I said, abort, do whatever you want, make several requests at a time, it's quite nice and I played the, we did and, yeah, I'm totally sold to React query, I don't know if there's someone that
28:01
doesn't, but I mean, something worth to explore, as I said, then if we have this in place, we can something that anybody is used to, so we are going to expand the architecture that is coming in React 15 and the normal suspense for clients because React query already is aware of suspense.
28:26
Reusable components, another thing that we have in mind is, okay, if we are going to do our next JS version of Volto, or the remix one, we
28:46
So the package is huge, it has a lot of dependencies out of it, so we don't want to depend on voltage just for using another framework and only use a couple of components here and there. So one of the things that we are exploring also is that start thinking into extract
29:06
the components to their own add-ons, release those add-ons, so if people need them, go there and use them in other frameworks or in other apps, I don't know.
29:20
The same for the request, so here I put the word unconnected, so the components involved are normally connected to the store, because they have to get things from the store, right? But some components are connected to the store just for what we said, server state,
29:42
so and then extract them is kind of difficult, because you have to unconnect them, then export the not connected thingy, because maybe the other framework that it's using doesn't have Redux installed, don't care really about that or is already using React query or yeah,
30:02
whatever thing, right? So by moving things to especially the server state to things like React query will help with that, because then we won't need a lot of components hooked into the store just because of data fetching and you could use also React query on the other side.
30:24
Completely transparent, right? Only by knowing which props are coming, there will be enough, right? Yeah, then another thing that we've been asked a lot is the ability to extract the Pastenaga editor out of it, so the editor for the blocks, what if someone wants to
30:42
include it somewhere else? We could able to do that if we go all this way and we finally extract things, which will also be nice. What about builds? Our build is based on Razzle, if you know, it's a boilerplate library that allows us
31:02
to do projects out of it, so these projects rely on core bolt, so then we can build applications on it. I mean, in this time as well, yeah, React ecosystems, yeah, I like more this compiler and yeah, I wrote my Rust compiler, which is the case of SWC, which is the compiler
31:27
for Next.js and it's super fast and it's great and whatever, and then another comment saying no, I built AES build because yeah, whatever, just to have another one. So there are a lot of new compilers and new builders out there that could be worth
31:43
to explore and if we can integrate it, maybe into Razzle itself, maybe in another boilerplate that we find, who knows, yeah, something worth to explore as well. We have regarding the package managers, we are using Yarn Classic right now in Volto.
32:04
After the conference, we will merge a PR that will enable Yarn 3 work for Volto, which is up to date and it's better, whatever, and eventually, what we really like in the Volto team is PMPM, and we probably will explore going there at some point.
32:25
So first, we will update Yarn, so we'll have an up-to-date version going in Volto 16, but the next time, we will explore PMPM because it's quite nice, it has very nice features. It will force us to review all the dependencies that we have there,
32:43
declare them properly because they're quite strict with that, but it will be, at the end, profitable for the overall project. Then features, yeah, all what you were waiting for, what we have in store.
33:02
So I will say that the main features that we have are these ones and I will talk about them. First of all, a new theming architecture. Why we need that? All through these years, one of the main concerns or the main questions that we had is, yeah, what if I need to implement a theme in Bootstrap because, yeah,
33:25
like the Retortor folks that they work for the town halls in Italy, then these town halls pushes for a very explicit design system that is based on Bootstrap, right? So what happens now?
33:41
And yeah, I mean, one of the things that I really think we have to put effort on is to get in a way that we have something like this. So we have the separation of the theme, so you can put any framework, any design system at the very top for anonymous.
34:04
Then common styling that can come from the CMSOI, yeah, we all know, yeah, what's the separation between CMSOI and these small things that you need, also in the theme, for example, forms for widgets, things like that.
34:21
So we could have this small subset of the CMSOI that is common and it will only be loaded in anonymous. And then when you are logged in, lazy load the CSS for the CMSOI where you have also something that is not tied to anything, really.
34:42
And yeah, I'm not saying that we're going to build this from scratch, but we have to find a sane way to define our CMSOI that is supported, that we can build on it, that it's not tied to anything, because one of the bad habits that now have the frameworks in the React wall,
35:00
at least, is that they come with their own theming system, which is wrong, which is, you know, I use emotion and the other uses style components, or no, I have my own Google thingies and things like that. So find a good agnostic pronoun.
35:21
It doesn't have to be a full-fledged design system, because we only want it for the CMSOI, but that has the basics that we can build upon, and then have this small bundle that only has the CMSOI, CSS, and the components that have it on it.
35:44
Yeah, also it's important when we build this thing that the CSS doesn't leak in that direction or the other way around. So we will have to make them very specific so this doesn't happen, but totally doable, right?
36:00
Then we have Quanta. Quanta is the new design system by Albert Casado that provides this sleek, modern look to Volto. We have it for some time already. It's kind of there waiting, yeah, where are you going to implement me? Didn't have time in the last years, but it's there.
36:23
It's nice. It's, I mean, I think it's amazing, especially in some points with block handling and things like that. We need at some point to make it happen. Probably since it will be a breaking change, same for the theme,
36:41
new theme architecture, probably will happen in Plone 7. We have to decide when this will happen, when this is ready, but I will let you know that we are already preparing with Rob. Where Albert doesn't know anything about it, but he's going to be at his house in Girona. But yeah, anyways, yeah, sorry Albert.
37:05
So yeah, so we can have this, the Quanta over the new theme architecture with the Quanta toolbar, which I think it will be huge also. Regarding that, we already have a POC, a POC about to put now, today, the Quanta toolbar into Volto.
37:24
It's waiting. We'll have to decide when we want to push for the Quanta toolbar. Could be, or if that we push it before Quanta happens, because it is something that we think that it will be quite useful,
37:42
because we are all the time finding places to have more CMS UI, real state in the screen to place actions and play things. And then the Quanta toolbar will be, so every block will have a Quanta toolbar, and then you have actions there like new block, delete, copy,
38:05
mutate, things like that. So it could be that it happened before. If it's for me, it will, but yeah, maybe I will find some resistance to that, but we'll see. It could be kind of breaking as well. So yeah, then implement the design system,
38:23
something that we've been doing bit by bit, and this is a very good sprint topic. We've shown the storybook at some point in some talk here and there that we have for Volto. It will be great to have that storybook completed at some point.
38:41
So every time that we do a new feature, a new component, we go there, write the storybook to show it at the documentation and have it ready for people to play with it if they have it available there. Next thing are slots.
39:00
Slots is something that is quite controversial, but I think personally that it could be great to have it as just another tool for building websites. I don't know if you know it about slots,
39:21
something that Tiberio has worked a lot on it. It's also almost really, maybe I'm lying there, but it's almost there. It's a mix between bullets and portlets. It uses the old tiles anywhere concept. I told David the other day that I read a post that he wrote a long time ago about,
39:45
and it struck me back in the day, because he was showing how to render a tile randomly. I don't know where it was, but probably footer or something. So this tile appear in the future from the edit, you could edit the tile in place
40:04
and add whatever you want, save that tile, and it wasn't a footer. I thought, crap, we need this. And having the ability that the tiles were far more lightweight than portlets and you can put it everywhere, so it opens a little bit the mind for that for me.
40:22
And it's precisely what the slots wants to accomplish. I mean, slots will be inevitable. It will be extremely lightweight. It will contain blocks, and that's the key feature. So what a slot will contain? Blocks, because it's the minimum atomic content
40:43
that we have in Volto. And then it could be assigned statically or back-end defined, and this is what Tiberio has worked on that. I think that the back-end is more or less really what we need is a good UX for that.
41:02
And this is something that we have to work a little bit, yeah, maybe have feedback from designers, from Albert, from someone that can bring us a good UX for that. And yeah, finishing features,
41:20
more features, random features that I think that we should also approach, and are also very good spring topics, please, the first three ones. If someone wants to help, I will be highly appreciated. We have the PR for the row grid,
41:40
column, group, block already in the list of PRs. It's halfway, maybe someone can take care of it. Could be that I work a little bit on it, especially in the teaser block. Let's see if we can make it happen for 16 still. Then another thing that goes tight with the first one
42:03
is the ability to drag and drop between nested blocks. So let's say that we have a block in the mainstream of blocks, the main content area, but then all of a sudden I have a row grid block, and then the ability to move blocks
42:22
between the nested block and the main content blocks, and also between row or grid blocks, so I want to move this into that. So we need this because now this is not supported by the current drag and drop system that we have. There's also a small POC, it's very rough,
42:43
someone needs also to polish and finish it, so please if you want it, that it will be amazing to have in both the 16. Relations control panel, this is something that we will also come in the next versions. Improve the transform run detection
43:02
based on agnostic markers, this is something that we've been after a lot, which we have transforms in place that gets some fields because they are named fields that are named, I don't know, for example, href or URL,
43:20
those fields automatically gets transformed, but it will be great to have a way to mark them and say no, this field and this field and this field is going to get the result we already transferred on it. Same for our other transforms that are in place, and this is something that we really, I think this is something that we want to have in the near future to be more flexible into that.
43:44
More things quickly, subscribe able context for every block, so for widgets especially, so we have the block configuration widgets, and every widget is blind, it doesn't know what other widgets has up and down, and at some point we needed the ability that a widget knows what value has another widget in that form,
44:08
and this is also something that we are missed, so if we could make some kind of subscribable context for every block so you can say, hey, no, I'm a widget and I know to know which my siblings are and getting the value
44:25
and know and act upon depending on other widgets value. Then another thing that we have in mind is use a full-fledged JSON schema form generation that it's not built by us, because we also found that we need validation at some point,
44:44
for sure at some point, and we need also same defaults, because now the defaults in the block settings, there are some rough edges and not always work as expected, so we think that the best thing is that at some point
45:02
we get a good JSON schema generation library, place them in there, we don't care more about that functionality. Then another item of the wish list is to rework the object browser and improve its API and features, because right now, yeah, after four years
45:20
it got a little bit Frankenstein, I mean it's good, it works, but developing new things for it has become a little bit cumbersome. Last one, so work on alternative backends. Next, we have Guillotina all these years, please give Guillotina some love, because yeah, I mean it's still a valid use case,
45:41
at least from my point of view, and it's something that Walter supports. We have Nick now also made by Rob, please go to his talk, it will be awesome, I cannot show you, it blew my mind, and one thing is that what Guillotina at the beginning so many years ago said,
46:01
hey, it's possible to build a compatible backend in a reasonable amount of time, Rob made it happen, and it's the proof that we could have made it happen, not only in the JavaScript side, where Node.js side, which Rob did,
46:22
but also on the Python side, so it's there, and yeah, thanks a lot for being here. Yeah, we have time for one question.
46:41
Nope, thank you. Has anybody worked with left to right input languages in Volto? I'm thinking Arabic languages and input from left to right languages within Volto,
47:02
has anybody done that? Not that I'm aware of, someone has worked on it, or had the ability, or had the requirement, not us, that's for sure. Maybe Retsu, yes, I mean, works well,
47:26
in your Volto side, I guess that it works well, right? Yeah, yeah, but do you have a culprit in mind,
47:43
special culprit, or, no, culprit, I mean, since you mentioned it, do you know? We're looking specifically of any Arabic language, we're supporting Uyghur Arabic language, and one of the things that we have in Plone 5 right now
48:02
with the classic is an ability to enter text right to left, and then displaying it is not the problem, it's actually the entering, yeah, they're actually typing in Arabic, and it's a challenge among all CMS, so if anybody knows about this,
48:22
just come to me afterward, I need to solve this one. Okay, thank you.
48:58
So 30 minutes, so I should go ahead.
49:01
Okay, so next talk.
Recommendations
Series of 44 media