A gentle introduction to Picocli
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 |
| |
| Subtitle |
| |
| Alternative Title |
| |
| Title of Series | ||
| Number of Parts | 287 | |
| Author | ||
| Contributors | ||
| License | CC Attribution 2.0 Belgium: 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/56856 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
| |
| Keywords |
FOSDEM 20221 / 287
2
4
6
8
12
17
21
23
31
35
37
41
44
45
46
47
50
62
65
66
67
68
71
73
81
84
85
86
90
92
94
100
102
105
111
114
115
116
117
118
121
122
124
127
131
133
135
137
139
140
141
142
145
149
150
156
164
165
167
169
170
171
172
174
176
178
180
183
184
189
190
192
194
198
205
206
207
208
210
218
220
224
225
229
230
232
235
236
238
239
240
242
243
244
245
246
249
250
253
260
262
264
267
273
274
277
282
283
287
00:00
Lattice (order)DiagramComputer animation
00:23
Software developerCASE <Informatik>Process (computing)Physical systemSoftware developerComputer animationMeeting/Interview
00:47
CASE <Informatik>Demo (music)Web applicationCondition numberFormal languageWeightLibrary (computing)Cartesian coordinate systemComputer animation
01:36
Interface (computing)Parameter (computer programming)Java appletoutputScripting languageJava appletCartesian coordinate systemInterface (computing)Utility softwareProduct (business)CodePower (physics)Point (geometry)Configuration spaceProper mapGraphical user interfaceView (database)Integrated development environmentRight angleNeuroinformatikProcess (computing)Demo (music)Condition numberNumberLine (geometry)WebsiteXMLComputer animation
03:20
Online helpBitGraphical user interface
03:42
Complete metric spaceComputer-generated imageryRevision controlParameter (computer programming)Demo (music)TwitterDampingCross-platformMultiplication signGoodness of fitDemo (music)Inheritance (object-oriented programming)CASE <Informatik>Condition numberRight angleAuthorizationSlide ruleCodeLatent heatAxiom of choiceCommon Language InfrastructureComputer animation
04:48
Witt algebraSpeciesCASE <Informatik>WebsiteJSONUMLSource code
05:10
Demo (music)String (computer science)Dependent and independent variablesGamma functionInformationAssembly languageEmulationInclusion mapDiscrete element methodUser interfaceGame theoryCivil engineeringRandom matrixRight angleNetwork topologyOnline helpResultantRevision controlQuery languageMereologyGroup actionCoprocessorPower (physics)Latent heatDirection (geometry)CASE <Informatik>outputParameter (computer programming)Type theorySocial classLine (geometry)Term (mathematics)CodecMultiplication signCartesian coordinate systemComputer fileDescriptive statisticsInformationMetropolitan area networkComplex (psychology)NumberECosLogicSpeciesRepository (publishing)Core dumpGraph coloringPRINCE2State of matterProcess (computing)Message passingDot productInheritance (object-oriented programming)VotingException handlingPrisoner's dilemmaComputer animation
11:42
Gamma functionGame theoryMach's principleElectronic program guideInformationProcess (computing)Line (geometry)Java appletMagneto-optical driveEmailMetropolitan area networkOrbitFrequencyAreaoutputWorld Wide Web ConsortiumParsingMaxima and minimaCivil engineeringMetreNetwork topologyCommon Language InfrastructureCASE <Informatik>Interface (computing)Latent heatParameter (computer programming)BitOnline helpFunction (mathematics)Web pageMultiplication signAuthorizationHookingError messageSemantics (computer science)Strategy gameLine (geometry)Computer filePerspective (visual)Term (mathematics)Electric generatorFunctional programmingOpen setLetterpress printingMereologyBoom (sailing)Electronic mailing listInheritance (object-oriented programming)Medical imagingData miningRight angleConnectivity (graph theory)Computer programFreewareGeneric programmingFormal languageCausalityOffice suiteWritingBit rateDescriptive statisticsSpacetimeReading (process)Social class2 (number)MathematicsUltraviolet photoelectron spectroscopyLogicSource code
18:11
Content (media)Demo (music)User interfaceCodeUniform resource locatorEmailSelf-organizationRight angleSlide ruleSemantics (computer science)User interfaceGoodness of fitWritingProcess (computing)Expected valueCodeAnnihilator (ring theory)Noise (electronics)AreaComputer animationSource code
19:14
Default (computer science)File formatDefault (computer science)Function (mathematics)Forcing (mathematics)
19:41
Rule of inferenceDefault (computer science)Game theoryWeightStandard deviationoutputVideo gameControl flowHydraulic jumpComputer animation
20:12
WebsiteQuarkLogical constantMatrix (mathematics)Web pageVirtual machineMatrix (mathematics)Software testingProjective planeHypermediaTheory of relativityInsertion lossMixed realityProcess (computing)TwitterVideo gameProduct (business)Descriptive statisticsInheritance (object-oriented programming)Physical systemTelecommunicationCompilation albumJava appletScripting languageLibrary (computing)Server (computing)CASE <Informatik>Source codeWebsiteRight angle2 (number)Computer animation
22:30
Matrix (mathematics)DataflowComputer animationMeeting/Interview
22:57
Physical systemTheory of relativitySpring (hydrology)Compilation albumCategory of beingMultiplication signWeb pageNatural numberThomas BayesLie groupComplete metric space
23:39
Common Language InfrastructureComplex (psychology)Category of beingConstructor (object-oriented programming)Cartesian coordinate systemGoodness of fitMeeting/Interview
24:06
BitHydraulic jumpDefault (computer science)Pointer (computer programming)Cartesian coordinate systemLibrary (computing)Meeting/Interview
24:33
Moment (mathematics)Radical (chemistry)Library (computing)Multiplication signSoftware bugCausalityShared memory
25:03
Link (knot theory)Computer fileMeeting/Interview
25:25
Library (computing)Centralizer and normalizerJava appletRegular graphScripting languageDistribution (mathematics)Revision controlMeeting/Interview
25:48
Multiplication signGenderGroup actionMeeting/Interview
26:14
Library (computing)Module (mathematics)Source codePoint (geometry)Web 2.0Common Language InfrastructureJava appletVideo gameElectronic program guideHydraulic jumpPlanningMeeting/Interview
26:55
Absolute valueHydraulic jumpSpherical capPlanningBranch (computer science)LaptopMeeting/Interview
27:19
Moment (mathematics)Freezing2 (number)Crash (computing)State of matterSpherical cap
28:01
Physical system2 (number)WritingPresentation of a groupCountingMeeting/Interview
28:32
GoogolComputer animation
Transcript: English(auto-generated)
00:06
Hey, everyone. Thanks for joining. This is going to be a gentle introduction to a tool called Pico CLI. By the end of the talk, hopefully, you should know a lot more about it. We're going to have some fun with Kotlin and Star Wars as well, because that's the Kotlin room. I would have loved to do that talk in person,
00:22
but, yeah, COVID helping, it's online again. My name is Yulain Roland-Bert. I'm a developer advocate for a company called Adyen. If you haven't heard of it, it's the company that processes payments of a lot of the companies you're using every day, Spotify, Blizzard, just to name a few, SoundCloud, a lot more.
00:42
I've also been named the Kotlin Global Developer Expert last month. I'm really happy about that. We're going to be looking into Pico CLI. And Pico CLI, very simple use case. One thing, it's a tiny library to create command line applications. I like the Amoto, it's got every main method, these are Pico CLI,
01:01
and we'll see that's actually pretty accurate. I really like it because of several reasons. It's very easy to use, we'll see it very soon. It's very rich, has a lot of features, and it works on all JVM languages pretty much, which is very interesting those days because we're getting diversified. It is also pretty active online on GitHub
01:20
if you look at the stars and documentation, everything is really good. You have used Pico CLI without knowing it. It's powering things like ADUP, Debian, it's on AWS, it's used by Microsoft. You have used it somewhere. So, if we take a step back before looking into Pico CLI itself,
01:42
let's look at the reasons why I would want a command line application. Interface, sorry. Few reasons, the first one is, well, it's nicer than having this big Java mess of things. That's what we're going to use in the demo, but having something shorter, more concise is interesting,
02:00
not only for you, but for your team, especially if you do something repetitive, but also for other members of your team, maybe your product owner or any other teams. It's better to have this very simple SW. Second thing that I also like from user experience point of view is Java becomes irrelevant. The JVM is not relevant when you run this command line.
02:22
So, having a proper CLI avoids having to enter into the world of Java. I don't care anymore. One of the very nice things about CLIs, if you use them properly, is they can feed into each other, right? Everybody does sometimes a pipe grab, I think.
02:41
Well, this is the same IDE. Command line interface, they are for humans, but it also can be used as pipes to other things. And for example, I could imagine a small utility that actually feeds code configuration to a kubectl command. So, that's a very nice interface,
03:01
tool for interface that a GUI cannot do. And usually, the documentation is also quite clear, right? You don't have to go to a separate website. Documentation is embedded into the command line itself. Hopefully, it's quite descriptive. So, you have a lot of power in a very small thing, and that's very nice.
03:22
Last but not least, some of us, especially developers, we really like to avoid GUIs if we can. So, this is a bit of a joke, but it's nice. Users are searching for those things, and there's a reason why you see all those big-name companies. They have CLIs as well, AWS, GitHub. They create CLIs because that's what people want.
03:43
Why Kotlin, right? If I do a CLI today, I'm going to go for a go, right, or Rust. Well, that's very true. If you can start from scratch, that's probably what you should be doing. But my code base is Kotlin, right? I have a five-year-old code base. It's all in Kotlin. It's all in Java. And I know Kotlin very well.
04:01
My team knows it. Everybody in my company knows Kotlin. So, if I want to be in that specific use case, then maybe Pico CLI is a very great utility. It's the best choice. We're going to be touching just a couple of those, but the documentation is crazy good for Pico CLI.
04:21
You can have colors. You can do multiplatform. They generate documentations for you. That's very nice. And the author is super reactive on Twitter, which I also really appreciate. Right. We're not going to spend more time in slides for now. We're going to look into the demo. We're going to be going through a very simple use case,
04:40
but we're going to be looking at, okay, let's go start with a simple use case. We're fulfilling it, but then we're going to try to improve our experience for the user. And we'll be using the SWAPI, the Star Wars API, which is nothing else than a website. You can query, and it gives you JSON back. And it does a lot of things. It works with, you know, it does the vehicles of the franchise,
05:03
the species, the planets, all of those things. We're going to be doing a simple use case. We're going to go for planets and people. Let's go. All right. Let me switch. For starters, a few words of introduction.
05:21
Backgrounds. I said we're going to use the Star Wars API. We're going to be doing two things, planets and people. This is, at the core, nothing else than a HTTP GET query with some filtering and some querying, some data classes just to get the information back. And so that we don't get, you know, JSON thrown to us,
05:41
I have a pretty printer, which allows me to have things pretty in a nicer way. And you can see that I can use Unicode. I can use formatting like bold colors, et cetera. But there is nothing, it's nothing else than a pretty print really. If I want to start using Pico CLI,
06:00
two things I need to do. The first one, well, as you would expect, the dependency. And then if you want the annotation processor in IntelliJ, then you're going to have to use the plugin. Right. Let's start small. We just want, okay, I have a main application. I want to run my command line.
06:21
It's not going to do anything yet. I just want to run a command line. Well, I have my main here. Pico CLI runs with a callable or a runnable, right? You need a callable or runnable. You choose one of those, whether you want to return or not. And then you simply insert the command annotation.
06:43
That's it. That's if we have a command line application. All of those are actually not required, but they are nice to have more information. We can insert the version, the name, description, et cetera, et cetera. So if we want to run it, there you go. I'm going to run my command line application.
07:02
Boom, I'm running. That's it. We're in business. Now, as I said, I want standard help options. Then I have access to my band, to the version. I have access to help. And it's auto-generated, right? You see it in front of me. I have not done anything else than inserting a name and a description, right?
07:21
Pretty nice, I think. Pretty nice, but not very useful. So we want to move forward. As I said, we're going to be running a simple use case where I want to be able to query people and I want to be able to query planets. Of course, it doesn't make sense to do both at the same time. So that's what we're going to be building here.
07:41
And I'm going to be introducing two different things. The first one is options. Options are typically the things that you see with a minus in command lines, right? It's the minus H, minus V, minus I. So those options are... Yeah, that's what they are, really. Usually they have a short and a long name.
08:01
That's what we're doing here. And they may be required or not, right? And if you do, for example, ffmpeg, then you might say, okay, this is my input. And then you might enter codecs that are not required. That's what we're going to do. Now, remember, it doesn't make sense to do both at the same time. So we're going to introduce the concept of a group
08:23
that is exclusive. So those two options are exclusive with each other, but I do need one. So I need either one of those, but not both and not zero. I think that shows the power of the tool very quickly. This is a use case that's not quite simple, but we're doing it in a couple of lines.
08:42
Last but not least, I want to be able to query, right? I want to be able to filter my search. And what I'm going to say here is going to say, okay, there's going to be a parameter. So at the end of my CLI, there's going to be a parameter. And that can be typically if you do ls to list the files in the folder and you do a dot or ls, you know, tilt to do my home folder,
09:02
the tilt or the dot, this is the parameter, right? That's what you have at the end. We all use the parameters. I'm going to use the first parameter, and I'm going to say, well, this parameter has an arity. Just like for a database, it has zero, one or n. Well, in that case, say, okay, there can be zero or one.
09:21
Maybe it's there, maybe it's not there. Once we have defined our command line behaves, then we have to implement the logic. And what we're going to do is, okay, we're going to say, let's look at which option has been selected. Depending on that, I'm going to make an API query for that specific type of thing,
09:40
and then I'm going to pretty print it. And the rest stays the same as before. So let's go and run it. We're running options here, options, and let's try a few things. We're going to try without any option.
10:01
Options, right. Pico CLI, as usual, trying to help me, giving me what I can do, but also telling me, by the way, you have to run one of minus C or minus B. So also giving me descriptive help, great for user experience. So see, that's what it's telling me. Okay, you have to use C or P. So let's go with, I want to do character,
10:22
and I want to say anyone with OB. Boom, OB one cannot be found one result. That's what we want, right? We're in business. I cannot do both, right? Again, it's doing these things for me. And then if I need the help, it's going to print help for me.
10:40
Right, pretty simple. We've done exactly what we wanted. Very nice money shot directly. So that's, yeah, what can I say? Now, this is all nice, but if you start using this tool, you kind of have to imagine a more complex tool. There's going to be a lot of options coming up. Maybe they're exclusive to each other. Maybe they are not, maybe some are required.
11:02
So it's going to get complex a lot. And if you've used a tar in the past, you may know that, you know, tar minus x, v, c, f, I always have to Google it myself. Things that are better in terms of your user experience those days, a lot of people are using subcommands, and that's typically what's used by the kubectl or by the GitHub command lines, for example,
11:24
where you say, GitHub repo, and then you end up in the part of a tree that is only valid for repositories, right? You're not going to get some things about geists or about forks. I have a repo, and I can view it, I can clone it, I can do those kind of things, while it doesn't make sense to clone the secret.
11:42
So that's very nice because it helps me as a user thinking in terms of semantic behavior and, well, that's what I want, right? I don't have to learn, and that's nice. So let's look at how we do that. Same use case, planets, characters. This time we're going to define subcommands, right?
12:01
Instead of doing our arguments and parameters, we're going to define subcommands. Two of them, this one is generic, right? It's also generated. The rest stays the same. And what those are, they are literally just commands, like we're basically working with a tree of commands that are interacting with each other. So this planet command, if we look into it here,
12:23
is literally a PicoCI command by itself. I could just, you know, have this one, have a main in there, and then planets would work. But it's a subcommand as we've defined it. And then the people is the same. In terms of logic, exactly the same, doing the API request, pretty printing, everything. All of the rest doesn't change.
12:41
We need a parameter at the end, maybe. Yeah, and that's about it. So let's look into it. Let's run it. Subcommands, two things. Again, I can run it like this, and it's going to tell me, well, you've basically just run the help. That's nice, but you want to be running commands.
13:02
That's one of them. You want to search for planets, people, so it helps me. So I can do planets, right? Boom. It's going to make a list of all the planets. Very nice. I can do something with that. Gives me that win. So already I don't have to do minus P anymore. I just know, like planets, boom, I mean already.
13:20
That's very nice. Now, because CLI is nice and because the help, as we said, it's just a tree of commands by themselves, I can actually search and ask for the help of specific things, right? This is a very simple use case, but imagine it's complex. Then I can help. I can get the help of a sub part of my command line interface.
13:41
Very nice. Okay. Well, that's all there is to say, pretty much. And just like before, we cannot do things that are crazy, like planets, people. That doesn't make sense. We have too many arguments. And again, because CLI is trying to help us with the error.
14:00
And that's one of the things that I really, really appreciate those days is I have an array of tools that I use every day. I don't want to have to learn them all. And I don't want to have to teach my users, right? So if the tool is helping my user, very nice. Error description, help, auto-generated, extremely important. Colors as well. So we're helped here to understand.
14:23
Some of you might say, okay, my use case is nice, but my specific use case requires me to have, like my options are not defined at the beginning. I don't know exactly how many sub commands I'm going to have. This has to be done programmatically. Well, you're in luck because because CLI also supports a programmatic interface.
14:44
You don't have to use annotations. Maybe you even just don't like them. I find them pretty interesting, but you can also run the same thing in a programmatic manner. And well, that is a bit more verbose and you're going to have to do the plumbing yourself, but we can do pretty much the same thing.
15:02
Define the common line, say that we want the standard options, define other common lines, right? And we're going to say, okay, this common line is going to have a parameter and then I'm going to build it. And at the end, I'm going to add sub commands. So this programmatic here interface is literally the same
15:20
as the sub commands that I just had before. So I don't have it ready, but we could run it. It runs the same thing, right? And then we have an execution strategy. So you cannot have to go into the documentation a bit more, but in case you want to do for loops,
15:40
you want to do functional programming and generate things on the fly. I don't know if you have a big documentation and you want to run a CLI to query against the documentation. For example, your open API expects, why not? I'm going to show a last example, which is pagination, right? One of the things that we see here
16:01
if we run planets is that it speeds out, you know, a hundred something planets for me, which is a little of a shame, right? It's not super nice. Again, from a user experience, we're trying to help our users here. So I want something like pagination, like I would have for a Git log, right? If I do Git log, and I'm going to go through pages and pages, I want the same.
16:20
Well, actually that's where I've seen, the author helped me there. You can hook into pretty much everything, right? We can still use our annotations, but because CLI interface is accessible. So what we're going to do is we're going to create a temporary file and then we're going to create a print writer.
16:41
And then we're going to hook into the execution strategy I was just talking about a second ago. And we're going to hook into the output of the command line, right? We're going to send the output somewhere else. We're going to pipe it to another place and then we're going to read it. So that's what we're doing here. Let's see pagination, paginate,
17:04
and then planets. Now I have pages to work with, right? Super nice. There is not much more that I can say about that. I think that's pretty much everything.
17:21
I will say one last thing. I will come back to it in my slides, but I don't want to come back to IntelliJ if I don't have to. You can run native image, like you can use GraalVM to actually create an native image if you want. This is the line that I'm using. Basically just making a fat jar,
17:42
naming what's the name of the output file we want. And then boom, I have a macOS executable that I can just run. The interest of that, you can create releases, right? You don't have to package and then create bash files and then maybe add something. You just have like this one file that you put in your path.
18:00
Somewhere you can just put it online. I've put it as a release on GitHub. Click on it, you can run it. That's quite nice, I think, again, from a user perspective. Right, let's come back to our slides. Right, I've shown a few ways to do things,
18:22
but again, always if you're creating something, especially a seller, you have to think first about your user, right? Who's going to be using that stuff and how can you help him not having to learn yet a new tool? And one of the quotes that I really like is this one from Martin LeBlanc. He says, a user interface is like a joke. If you have to explain it,
18:41
it's not that great. I really like that quote because as we've seen in the examples, we can do much better than what we would typically think of. I don't want to have to read the code. I'm already using 10 CLIs every day, and I think a lot of them are doing a good job today, so we can do the same. The expectations are quite high up those days.
19:01
So here, subcommons is a good way to use semantics to actually give a lot of value to the people, and they might just randomly write stuff, try stuff out, and it works. Best practices as well, one of the things that I see sometimes is if you create your own CLI, that's nice.
19:20
Try to use sensible defaults. If you can say, for example, okay, default is going to be YAML and output. You can change it if you want. Try to use the defaults wherever you can because it allows the user to not have to think and to have to keep things very concise. That's much more helpful to write something like the left example than the right one.
19:42
And another one is I see that sometimes there are unwritten rules and defaults in the industry, just like in video games. If you put the jump button at the top of your controller, then people are going to be angry. Same here. Minus I, I expect an input. Minus R, I expect something to be recursive.
20:02
So try to stick with the industry standards, even if they are not written anywhere because you're breaking game design. You're going to make your users angry. Last thing I already mentioned, it's Try Native Compilation. Super nice. It creates bigger executables, but they are much, much faster.
20:21
On my machine, it goes from one and a half seconds to almost instant. Very nice if you can. Right. As a conclusion, if you want to start using PicoCLI, I recommend you search for a project that you use often. Something like maybe performance tests, like your release.
20:41
Maybe you're using like this little tool to upload to the server. Whatever you see, where you have a script and you run like this Java minus C or minus something, try to find this use case first because that's the money shot. You can directly, boom, use it and it's going to be making people happy. And if you care about user experience, you might see adoption grow.
21:01
Maybe your product owner will start using it. Maybe other teams will start being interested in that tool. So that's what's nice about PicoCLI. And Try Native Compilation if you can, of course. It will, you know, it will make it not run on certain systems, but it will make it much faster on your own system.
21:21
And I think those things are especially more useful on CI servers, for example, on the machines that run CI. If you have like a few tools that it will help people debug. They can just read, makes more sense. And last but not least, try to have fun doing it. That's what I always start with.
21:40
Couple resources, not crazy, but the PicoCLI website is super well-defined and well-written as well. So if you, one of the things I like is they have a single page. So you can control F on the whole page and then you're done. The source of this project is on GitHub. Another very good guy that I found is the Quarkus.
22:00
Quarkus has a PicoCLI guide, and I think it mixes quite well with the Spirit. Quarkus and PicoCLI, they mix together because Quarkus also is very light. So, you know, they strengthen each other. If you need to contact me, there is the Twitter in the description. Thank you very much. I did hope, I hope you enjoyed.
22:21
Hopefully you want to try the library. You can find me on Matrix. That's how Fozem is going to do the Q&A, but you can also hit me up on Twitter if you want. All right. Cheers.
22:46
Dive with the questions. They keep on flowing. So the first one, the most avoided one is, have you tried kotlinac-cli instead and how does it compare to PicoCLI? Yeah, that's what I was telling you like a minute ago, and I think maybe you can fill in
23:00
because you do have the experience, but when I was searching for a tool, I've seen klikt, I've seen kotlinac-cli, and I've seen PicoCLI, and I like the single, the fact that like on PicoCLI everything is on one page, so you can just control F really quickly. And I really like the annotation-based system because we use Spring everywhere, so that's why.
23:22
And I was also dabbling with Quarkus at the time, and they really had an obvious relation with the GraalVM native compilation. So in short, very shortly went for PicoCLI, didn't look back, but I'm happy to have your experience, actually. Yeah, on that side, really quickly,
23:41
I think that the perk of kotlinac-cli and klikt is that they provide some more idiomatic way to do CLI with Kotlin, like property delegates and other constructs. But definitely PicoCLI looks like the most powerful of all of them because it has extensive documentation, so a lot of APIs. So if you have more complex CLI applications,
24:03
that's probably the way to go. You do see it's not completely idiomatic, like if you start having like default values and then you start having to play around with null values and stuff like that, which is a bit less fun. But we didn't have problems with that, so... That's true, that's true.
24:21
So let's jump on the next question. So on the CLI topic still, do you have some libraries to recommend to support the graphical-like CLI applications in Kotlin, a la Uncurses? Yeah, as I was saying, I haven't found something for Kotlin, though I think Mathieu, or is it Martin, shared something that looks really interesting with Jetpack Compose because, you know,
24:42
of course Jetpack is a thing to be at the moment. So I'm going to have a look into it. The other one I looked into is, yeah, Charm. If you have a minute, do try it in your terminal. It looks freaking amazing. But it's not Kotlin. So I don't know how much cross-support you can do. But no, the short answer is no, I don't know any.
25:02
Awesome, so the library is charm.sh. The link was also shared in the chat room if you want to follow up. Next question for Martin. Do you have any... Sorry, the question is, can I make this work from a file main.kts? Well, I think you know. The short answer for me is why not.
25:22
I don't see any reason why not. I haven't tried. Yeah, I can follow up on that. Yeah, you can actually do that. I think I did it in one of my scripts. It's yet another regular Java library that you can get from Maven Central and use it. Next question. Do you have any recommendation how to distribute CLIs written in Kotlin?
25:40
Just ship the fat jar, ship at this zip, put in an npm package, something else? So what I have done is, because everybody was on a Mac around me, so we have shipped native versions. So I was just shipping the native executable. That's how we've done. Shipping a fat jar next to it
26:01
is also I think the next best thing for me because that's what people are used to most of the time. I haven't tried npm. I'm curious if you have experience with it, actually. I do. It still feels wrong to me to distribute in Java libraries via npm,
26:21
mostly because you can distribute the sources, and you can use tools like include build on Gradle and let people rebuild that module. You will have implications on the performance of your build, but you have all the benefits of the build from source so people can actually change it and rerun on the fly.
26:41
So it really depends on your ecosystem. Like, if you're running a CLI for a web app, it might also make sense to create a npm package for that. It really depends. That's a good point. My experience is in a Java ecosystem for backenders, so I was kind of out of the question just because it doesn't make sense.
27:01
Absolutely. So let's jump on the next question. We already touched and clicked, so I will jump on these other questions. That is, sorry if this was answered before, but are there any plans to move from KAPT to KSP? I have a bunch of capped scars. And, yeah, I can conquer.
27:20
To me, that's actually a KAPT support because CLI was the thing that frustrated me the most. Like, I had a five-year-old laptop, and it was making IntelliJ completely freeze, like, literally freeze for three seconds. So I was looking into it. That's the first thing I checked last week. I haven't seen anything on the PicoCLI issues
27:41
that says, you know, we're going to support it. So it looks like it's, you know, up for grabs at the moment. But, yeah, I kind of agree. If you ask me, literally, I actually disabled. Like, I know PicoCLI is not a disabled KAPT. Awesome. Because the performance impact is just too much. Yeah. Yeah, so I think we are done with questions.
28:04
We still have some seconds. I will just follow up on what Martin wrote. It says that NPM also has auto-update. So, but it does feel super wrong. Well, that's also debatable, Martin. Maybe you should join us in the room afterwards.
28:21
We can talk about it. I think every package system has its own pros and cons. So it's hard to make everyone happy in the room. And we're going to be cut.