 So I want to briefly introduce the background where NetBeans was, where it's going, where it is. And my colleague Jan will do a demo of some of the new support for LSP and related editor functionality. So the story of NetBeans begins in the 90s before being part of some micro-systems. A group of students in prime created an IDE for this cool new language called Java. It was acquired by Sun and was free and open source pretty much from the beginning. And it was a way for Sun to position Java and to provide a low threshold into point and into getting into the Java ecosystem. And it was really fully controlled by Sun, but at the same time there was this vision of having a community around it. So there were two, in particular two organizations, one called NetCat. So this was a NetBeans community acceptance testing program and also something called the NetBeans Dream Team. So these were evangelists and external people from outside Sun who were talking about NetBeans and so on. And increasingly the focus of NetBeans changed to be more than just Java. They became more generically focused on the number of different languages. And as this community was being built, they wanted to have more and more say over the direction of the project. So we had this community of people from all over the world who were not attached to Sun, but who were really attached to NetBeans. And they wanted to be more involved and there was this constant push from the community saying, hey, we don't want to simply file issues. We want to actually be involved in the project, in the direction, in the roadmap. We want to really be engaged in this. So there was constant friction between those two different interests. So then, of course, there was the acquisition of Sun by Oracle and NetBeans was simply part of that acquisition. It was one of the many different products that went into Oracle. And the question was, of course, Oracle was invested in JDeveloper and is invested in Eclipse and now has NetBeans. So obviously NetBeans is going to fall out of that stack within Oracle. And I work for Oracle. I was working for Sun. And definitely we were concerned about this too. But quite quickly it was clear that NetBeans was being used in different places within Oracle and JDeveloper itself became re-architected to have its module system, its bootstrap system became re-architected on top of NetBeans. And a number of features from NetBeans ended up in JDeveloper. So for example, the GUI builder from NetBeans was re-used in JDeveloper and the profiler from NetBeans was re-used in JDeveloper. So there was all kinds of needs within Oracle for NetBeans. At the same time, there was this kind of shift in the technology world from, on the one hand, sure, Java is great, but JavaScript is also great. And Oracle has gone in that direction, like anyone else I suppose. So on the front end, so the folks increasing you within NetBeans became not only Java but also JavaScript to support that technology change in the industry. And the question was asked at some point, look, we have this very strong community, they want to be more involved. Oracle's core business is not providing tools. So it doesn't make sense to put NetBeans in a place where the community can more easily get involved because the blocker for people contributing code to NetBeans was they had to sign an Oracle license agreement which basically meant giving all the code away to Oracle. And that was always a blocker and also the idea, a concern for many people was, well, why should I contribute to something that belongs to Oracle? Doesn't Oracle have enough engineers to create the features that are needed? Why should I have to commit to something that is actually Oracle's? So at some point, this was in 2016, the decision was made in Oracle, hey, we need to put NetBeans in a more stable governance model, in a governance model that people more broadly will be able to contribute to more easily. And Apache was the one that was chosen and I'm really happy for that because what is really nice about the Apache Software Foundation is that it focuses on individual contributors. It's all about individual contributors. Everyone on the mailing list is equal and when we vote, every single vote is equal. There are no companies attached to Apache projects. No company can have a dominant say in any of these discussions and so on. So it's all individuals, which is exactly how NetBeans has been working in all those years. So then this decision was made. We want to share the cost of ownership. We want to put NetBeans in a governance model that suits it, which is Apache. We don't simply want to put NetBeans, for example, on GitHub because then you have discussions about governance, essentially. So the good thing about Apache is you get this whole governance model out of the box and it enables Oracle to continue to be involved, to continue to contribute, and in a moment I'll show the contribution, who's contributing, what and so on and you'll see Oracle is still heavily involved. So then that decision was made in October 2016 and then the question became, okay, what does this mean? We've said we're going to donate NetBeans to Apache, but what is NetBeans really? Is it the code? Sure, it's the website. It's this community, it's that community, it's this and it's that. What exactly does this donation actually mean? So we spent some months figuring out what we actually meant by that and so I'm the person within Oracle who's been kind of overseeing that transition process in more or less informal capacity and there's discussions on the Oracle side, there's discussions on the Apache side, there's a lot of auditing because Oracle constantly say, well here's a repository, good luck, it belongs to Apache now because there could be code in there over the last 20 years of NetBeans existence that doesn't really belong to Oracle, by accident somehow. So every single file at some point had to be audited because we discovered that, or we realized, there's a toolbar in NetBeans with different icons for opening different browsers. One of those browsers is the Google Chrome browser. So there's a nice little icon in there, Google's icon, Google's logo is in our toolbar. Can we donate Google's logo to Apache? No, of course not. Then we have to look at every single file, every single picture, every single line and every single file to audit it before we can give it to Apache. And once it's in Apache, a second process begins because Apache can't release GPL code. Oracle doesn't care, Apache does. So the second process has to begin in Apache to scrub that code, remove GPL, remove binaries. So it's a massive process. We are about two thirds of the way through this process. We're still in the incubator. We're right now talking about leaving the incubator. Our mentors in Apache, I mean Apache is wonderful, they give you mentors, they give you a VM, they give you GitHub, they give you a governance model out of the box and everything we needed, all the structures are there. So we simply had to adapt to these new structures and we've been doing really well in that sense. It's a really large project in Apache terms. It's got the most lines of code competing with OpenOffice in that sense. And we've done two releases in the incubator. So Apache NetMeans 9 and 10 and we have Apache NetMeans 11 coming up in March. We want to do more frequent releases and we've more or less said we want to do two releases per year. We want to commit to two releases per year and two optional releases in between. So there could be a minor release in between. And since we've decided to do two releases, it makes sense to align with something. So our next release in March, which happens to be the release of the next JDK, JDK 12, and in September, which happens to be the release of JDK 13. So we'll be in line with those different JDKs. So at the same time, we're moving out of the incubator. So before, Jan, there's a quick demo. This is what the NetMeans.org website looked like in the past and it's still like that. We're in the process of moving everything to the Apache equivalent. So this is our new website. It looks much more modern and so on. It's quite far from being what we wanted to be, but we have the starting point. We want to make it much more visual and graphic and show the editor and so on, but it's a much more modern site, clearly. So we're moving content from here to there, but here as well, before we can move something to the Apache site, we have to have it audited. So Oracle has to donate each and every HTML file, each and every icon, each and every everything. So it's a process as well. So here's the new site. And so, for example, we're moving tutorials. So here's an old tutorial on NetMeans.org site. And here is that same tutorial on the Apache NetMeans site. And the best thing about it is it's now an ASCII doc. I mean, logically, but NetMeans has this long history with everything in HTML. But the really cool thing is everything is on GitHub. So if I have a problem with this tutorial or if something is wrong with it, I can go directly into GitHub and do a pull request on that tutorial. And then people can review that and so on. So for the first time, we have a really nice and logical way of people contributing to our tutorials. They can make the changes themselves and provide pull requests. Here is the Apache NetMeans GitHub repository. And we've completely restructured this because we had, like, thousands of top-level folders. Inside NetMeans, Mercuro, at Oracle, we had this long list of all our modules, which became unmanageable within GitHub. So we have reorganized those modules into different clusters. So these are clusters of modules, and if you're familiar with NetMeans terminology, a cluster is a collection of modules. And this reflects what you see in your installation directory. So there's this Enterprise folder here. You click on here, and here are all the modules that provide the Jakarta EE, Java EE features. So these are all in GitHub right now. So here are all the Java modules within the Java cluster. So we've reorganized everything to make it more manageable. So the top-level folder is actually quite, not that much. So here you can see who has contributed. So everything is transparent for the first time. And inside Oracle, we had, like, one person doing release management for NetMeans, and that one person knew everything about release management. But no one else knew how that one person did it. And if that person was run over by a bus, we wouldn't have been able to release. In Apache, everything is documented. We're simply following Apache's release management steps when we do a release. So it's really well organized and transparent. So here are the people who have contributed since the very beginning of NetMeans in Apache. And so you can see a young Ahoda right here, the most frequent contributor from Oracle. And then the second person is Matthias Blazing, so somebody from outside Oracle. He's in Germany somewhere. You need to use in Japan somewhere. So these are not Oracle people. And then Jair Slavtulach, the founder of NetMeans, still working on NetMeans. And this is me, and this is someone else from Oracle. And then the next few are not Oracle. This is Antonio Vieiro in Madrid. This is Thelina in Thailand. So it's a mixture of different people. It's probably about 50% Oracle, 50% not Oracle. There are a number of projects based on top of NetMeans, and you'll find out about Praxis Live later today. So this is a multimedia, hybrid visual live programming project. You'll find out about this later today. And another example is Michael Wimmer's organization's ODS open platform. So this is an open platform for air traffic control in Bremen. So these very large systems created on NetMeans that are also impacted by this. And we've contacted all these different organizations up front to say, hey, we're making a move to Apache, or do you think, do you want to be involved? So we really want those different organizations to be involved. And the good thing is, these are organizations who know all about the NetMeans APIs because they've been creating applications on top of the NetMeans infrastructure. And to do that, they know all these API classes, top component, node, and they know about this, in some cases, about the editor functionality. So these are the kinds of organizations we would like to be more involved in the direction and the development of NetMeans. And a number of these organizations, also NATO, Boeing, Airbus, this very large systems created on top of the NetMeans infrastructure, they have generic functionality in their systems that they could contribute to NetMeans. And we could have that within our GitHub repository rather than in all these different products. So that the products, all these downstream products can be much more focused on the unique features rather than generic features, which would be in our shared repository. So yes, I mentioned the roadmap. So we released a patch on NetMeans 9 in July, August last year, and we released patch on NetMeans 10 in December. We have coming up the next release in March, which will support Geneka 12, but also will include for the first time our enterprise modules. And the next release after that will include the C++ modules in September. That's what we're aiming for, and in between we might have some other smaller releases. One small thing before I switch over to Jan's demonstration of some new features, but this is what NetMeans look like in the last release by Oracle. And a discussion, I mean it seems trivial, but a discussion that we've had for a long time is look at this new project dialogue. Somebody creates their first Java application. Imagine you're creating your first Java application. So NetMeans is often used at schools and universities and so on. People learning Java for the first time. They create a new Java application. Without knowing it, they have created an Ant-based application. Now a lot of people have said, hey, in the real world, Maven is much more widely used than Ant. Wouldn't it make sense that the first application someone creates is not Ant-based, but Maven-based? Well, Maven is all the way down here, and this is called Java. This is called Maven. It doesn't really make sense. So what we've done for the upcoming release, so this took months of discussion, and this is the wonderful thing about Apache. Everything happens on mailing lists. Everything happens... If it isn't documented on the mailing list, it never happened. You can't have a phone call and say, hey, let's do it like this. You have to do everything via mailing lists. So this took months of discussion, I can tell you. And what we now have is Java with Maven, Java with Gradle, Java with Ant. And so we've solved a couple of things here and created a new problem, but we've... We've solved some things. So one thing we've solved is we have put Maven first. So the very first thing you see as a newbie is Maven at the top. So everyone's happy except for the Gradle people. That's fine. What we haven't solved is if you're a complete newbie, you've never touched Java before. You open this thing and you don't know what is Maven, what is Gradle, what is Ant. This was a nice thing about the old structure that you didn't know what those things are, so you would just create your project. So there's still a small problem here, and one suggestion is that there might be a category that just says Java, and it would link to the Maven project, and at the end of that wizard you would have a Maven-based project. There are no easy answers. I'm sorry? No one reads the description field. I don't think people read the description field. So maybe we could say something here about this is a logical first project for you to create or something, or big capital letters. I think that's Java before I start here. Blinking. So these are the wonderful discussions you can be part of. Okay, so we're going to switch to a quick demo, but how you can be involved, main English, I mean, Neckpins is like any other Apache project. It's like Apache Maven, Apache Groovy. It's all standard. We don't have to learn anything new from the memories of Apache. We just pick up whatever Groovy has done, Maven has done, and we're just using that within our own project. One interesting thing to see is this page. So this shows statistics from Apache about it compares the different projects to each other. And what you see here is a little circle here showing the different sizes of projects. So this is everything else, but these are the largest projects. So you can see Neckpins right now, 7.9, let's say 8 million lines of code. Next is OpenOffice, you can see Flags. So it's really the largest project, and we have about 3 million lines of code coming. We are still in the auditing process of some parts of Neckpins. We decided at some point we won't wait for everything to be audited. We're going to do it in batches. The first one was focused on the platform and the Java tools. The second one was focused on the enterprise tools. And the third donation was tutorials. We're working on the fourth donation, which is C++, and after that there's at least one or two more after that. And the other funny thing is it all takes so long that at the point where we are ready to do a donation, the person in Oracle who signed the previous donation and who understands the process has left or has been fired or something. And we have to find a whole new person and a document to explain to them that years ago Oracle decided to give Neckpins to Apache and this document has to be signed. So every time we have to re-educate a whole layer of people in the Oracle management structure to actually get the document signed to hand over that document to Apache. So it's all interesting dynamics. We've learned a lot about how all the pitfalls of being a large enterprise that wants to transition a project to a foundation like Apache or Eclipse and so on. So you can contribute in multiple ways. A simple way is there's all these tutorials that you can review and you can provide pull requests on anything that is incorrect. That's a simple way. Just look at the tutorials. We really need feedback. We need to be told what's wrong with them or told that they're right. Issues, file issues, join the mailing list and get involved in discussion. This is simply another Apache project. It's the one and only project in Apache that's a GUI tool. All other things are libraries and this is another challenge here. We have all these icons and logos and if Oracle can donate them to Apache it doesn't necessarily mean that Apache can release them because are they licensed correctly? So if you're a licensing expert, if you have some legal twist in your brain where you enjoy looking at licenses, please join us because we need people like you to work on this. So let's look at some upcoming features to wrap up this session. These are new and upcoming Java editor features in Apache NetBeans. If there are questions, this is a good time. You can install the C++ modules from the Oracle release from the 8.2 plugin portal. The really nice thing as well is many people thought, well, who uses NetBean for C++? We have seen so many people complaining, where is the C++ support? Now that we don't actually have it in the distribution right now, so it's been a wonderful way. The fact that we haven't included it yet means that we're getting all these complaints. So we're getting all these people saying, hey, we're using this. But it's coming in September release inside NetBeans, but you can use C++ right now today. Registered in Apache NetBeans 10 and also in the next release the URL to the update center for 8.2. It's already registered there. So you can go to the plugin manager, look for C++ and install those tools in that ID. Okay, demo time. Thank you. Okay. So hi, I'm Yan. And like I am an individual contributor to Apache NetBeans. My day job is the OpenJDK. So what I care a lot about is Java and new Java features, especially language features because I'm doing the Java compiler in JDK. And so I will talk a little bit about things that NetBeans can do for everybody who wants to try new Java language features or who develops OpenJDK, which probably no one does here, but it's okay. So for a very long time NetBeans was using the Java C or the APIs from Java C to model the JavaScript to parse it and provide some model on which the features can work. But until recently NetBeans had a special fork of Java C which was tweaked so that the ID can work with it better. But when NetBeans was moved to Apache there was a change in that and NetBeans can use the Java C that is in the JDK. It still has some rough edges, some things don't work or don't work as well as this and the Java C. So for general users and Java C is still better but if you want to try new language features it's fine to try or work with the Java C from JDK. And the point of that is there is a soft scope and you see this instance of string as and you might have noticed on Branget's talk yesterday that this is pattern matching and it means that if the variable O is of type string there will be a new variable created as of type string and the O will be casted into the new variable and this version of NetBeans is running on JDK that understands this new stuff in Java which is a prototype of course because it's not approved and so on and it's not in the standard JDK and NetBeans itself doesn't know basically anything about this new feature but since it's running on on the JDK that understands this new feature it shows no errors because the Java C can understand this you can get the code completion on this place sometimes it's a little slow I don't know why yeah okay the Java and so on so the ID itself doesn't understand this construct but Java C does so a lot of things are working but of course not everything so for example you may be able to see that the s is highlighted here but the declaration in the instance of it is not because the ID itself doesn't understand the construct yet that may be coming and related thing a different but related Apache NetBeans since 10 has support to directly work with the OpenJDK source code Java source code mostly so basically what you can do is you can open the modules from OpenJDK like Java base here and it will open the module and I have to admit I already had this project open it takes a little bit while before the ID understands the project and so on and you can let me try to make this bigger you can browse the the source code so I have, I don't know this is joy to Rekek's pattern but ok so this is for me this is reasonably cool because I can work on the sources without anything else but what's even more cool at least for me is that OpenJDK is using a special framework for tests that is called JT-Rech and it's fairly special because it's very old because OpenJDK started this testing before, sorry not OpenJDK started this testing before these new frameworks so called so normally or I don't know when I joined JDK wasn't very easy for me to debug tests it was actually very complex so if I had a failing test I had to do a lot of stuff to actually know what was happening in the test was happening in the JDK but in NetBeans so this is a test that is testing the joy to Rekek's pattern and it has like this other is a description of the test for JT-Rech and what NetBeans can do now is that you just say debug test and after a little while it will start the debug and you can debug as normally it should all work we can yeah we can let the test run for a little and it will stop at some place where you can actually jump to the source code and this is all this all was in opportunity instant so it should yeah so we can look into into the actual implementation in JDK debug that see what it's doing and yeah and like for me this is very cool because I can actually debug actually when I develop I manually try and in this cases I simply create a test and debug the test it's much easier than start a process somewhere and attach to it this debug it's easier to create a test and yeah so how much time do we have okay, probably enough yeah so this was this was about Java and for another new thing in Apache NetBeans and this part was in 10 but it's better in the upcoming release is some elementary support for the language protocol or a client for the protocol and so as a demo to not be controlled too much there is server for the LSP that supports the shell script so this ID is using that that using that server to provide the editor features for the bash scripts or shell scripts you can see there is the navigator left bottom corner there is a function it's actually coming from the server we can if we press like control click and run it will jump at the function that we are calling if we break the code we get some errors from the server that we show and yeah and you notice there is syntax highlighting that that's actually using a grammar from visual studio code the text made grammar and so I have to thank our eclipse colleagues because both these things like the client for the language protocol is based on the LSP for j and I need to be careful because there is LSP for j that is the library and there is LSP for e and that is the implementation so I sometimes make it a wrong way and the syntax highlighting is using text made for e I think that's it but just the part that renders the text in eclipse just the part that passes the cameras and Alexis the source code and so just to demonstrate what it means to add the support as we have seen to net beans right now for the language client what needs to be done is to have a plugin that starts the server and really stress it for some mind type you also need to have what we call data object for the mind type but there is wizard for that but basically what you need to do for LSP is start the server and return some kind of description where is input output and it's good to send the actual process that is running the ID can kill if needed and for the grammars it's even easier there is declarative description if you place the grammar at the correct place and edit the correct attributes the ID will like find the grammar and render the source code color the source code based on the grammar so okay I think that's it I wanted to show yeah any questions so the question is whether in the for the GTH support where the hospital tests are working and the answer is that I am not sure I think not at this time but I didn't try okay no not right now but definitely no debug but for native parts you can now at least open them but not okay sorry I made a mistake there is a C project for hotspot and it's possible to do something with that but I don't do hotspot so I don't know exactly how that works but in Apache NetBeans there is no C support yet so in any case you would need the C support from the old version of NetBeans I tried it two years ago and there are NetBeans projects in the JDK but it doesn't fit in the open JDK no no NetBeans like for the open JDK modules they have this module in force and that means understands the layout and the module in force so you don't need for opening the open JDK modules you don't need any other metadata for the modules that are Java it's it simply opens in the repository you don't need any XML there is a difference to how it works there used to be new project folders in the JDK and it sometimes works but it didn't work this is a different implementation using the module info class from the JDK and he is the guy to blame if it doesn't work