I will be talking about liberal physicist Python API, which we call Pi, you know, and it
is one of all the most popular API to use for any kind of extension development nowadays
because it's easily accessible, but the whole Python you get approach while it has lots
of NFS and making it really easy to use, thus have some implied limitations which you
can do some ugly stuff to work around there. That's what I'm going to be talking about,
and I'm far back my way, so let's say that part. So why Pi, you know, almost disregarding
basic all other unabindings of liberal-fest needs you to compile it to some kind of architecture,
and then that easily kills it being a truly cross-platform. So, Python, when you use Pi,
you know, since liberal-fest already picks up it, it's on Python version, a truly
cross-platform, so it makes super-sense to use it, you can just, yeah, when you write
some kind of extension or script on it, it will work almost everywhere. If you're not
using some always specific Python thing there, I don't know, that's also possible, you
can do that, but other than that it should work. So usually, Python is a popular language,
we could say everybody knows Python. It does have this huge, extensive library ecosystem,
and there's lots of stuff you can take that, there's lots of different data processing tools.
I don't know, nowadays we can also integrate AI and whatever. And Pi, you know, comes
with the Uno Helper, which I really like, usually when you create any kind of liberal-fest
interface, actually registering that is quite complicated, but with Pi, you know, I will
do some, I will screen on code on screen type of deal, so you just need to import the Uno Helper,
and then, from that you can get the implementation helper, and as long as you just
give it, the actual Python implementation, implementation name and the service name is good
to go. If you use something like C++, you would need, I guess, three different C-call type
functions to register stuff, it gets really ugly real fast. A lot of people play this
I really didn't use in just Pi, you know. Okay, what limits I'm talking about then,
like, if Pi, you know, it's easy to use, you avoid boilerplate, okay, maybe before
this I should also mention that, like, do whole Python and get burst ping, what I mean by
that, in terms of Pi, you know, you can just, when you're using any kind of integer, that
will be three, will be converted to any kind of long short or whatever type of Uno function
you're calling, what type it expects, and when you get it, you can just use it at whatever
as well, usually, in any other language other than basic, that liberal office supports,
you need to explicitly set things up. But when you come to sequences that, you know,
extensively uses for anything list-based or whatever, if they have a type, the Pytonic
approach basically can't do this because the sequences are represented by tuples and tuples
are mapped to a sequence of any, always, and if you just pass a, any sequence to a function
that doesn't expect any sequence, it doesn't work. For, they are some kind of similar problem
with Enals Python, doesn't have enough, and as for that, you can pass in integers and liberal
functions, actually, expect the specific Enalm type, that also makes things fall apart,
and the last thing that I kind of have an e-cabot is, you can't really purely implementation
of an interface on the goal reliably, at least if you're not doing the work hands that I'm
going to talk about, you can't use something like, easy instance or, like, the liberal office's
own x-interface purely interface to get, if an interface actually implements some interfaces you're
looking for, some implementation, and the work hands for type sequences is this ugly thing
through Uno, you can do Uno that any, then in, with this thing, you can actually define the type,
and you can then give it this triple, which it will basically try to cast each item in the
triple into the type, that lets you represent these, for instance, a sequence of short, instead of a
sequence of anis, and then if you've got to use this, you've got to use this Uno that
in work with it, which gets quite hairy, as you can see, like, you need to give it the object,
and then the name of the call, all of those are just strings, like, nothing's fancy going on there,
and then you need to give it the property itself, and then inside of that, you, like, just look at
the end of the sign line there, how many parentheses are there? This is just hard to use the
level out. I don't really know, but maybe another day is with someone who's interested in
contributing into this area, it might be possible they actually do this runtime and get rid of
this as well, and you could just, yeah, just don't trick them. Yeah, so what about checking the
level, in planetation of an interface? This is basically disturbed from this, asking the broker's
form, a post, what you've got to do that is a very care and as you need to get to pay, you know,
interface, which is this prototype, what I mean by, is the only interface that pie you know
interface, which is basically this strictly presentation of the underlying type, and then you
can pass that, you know, get typed by name, which gives you the actual underlying type,
you can't really reference that directly through Python suddenly, and then finally you can
use purely interface to actually see if purely interface will work, and if you actually
implement the interface or not. Yeah, for the Enemies, it's quite similar to the
sequence thing, you need to actually define what type of Enemies is, then just give it a number,
and the Python will cast it into that, but it's ugly. Some tips and tricks that I want to
mention was like, this is from the readme, actually, but I never got around to reading it
until I was preparing this for the real presentation. In Python, I loaded a pie on the
pie, you know, if you set the bug, like on and you compile a lib service, you will actually set
free all the exceptions and principles of Python, which are not naturally free. They don't
appear anywhere, it's very hard to debug, this makes it easier. I just wanted to show you lots
of different UI stuff, but yeah, maybe I solved a bit too much. Yeah, last point I wanted to mention
is that lib rowfaces generally, Uno in general is ideal to say a great application,
development framework, but it lacks a decent API. So what you can do with Uno is actually
all types of stuff you could basically re-implement any kind of UI integrate your own UI toolkit.
Anyway, I just wanted to show you that. Let me just cut this short.
For instance, you could, oops, I forgot a better Bitcoin, like everything is dynamic, you could
actually change this button position in real-time, whatever, and also you could define custom
rendering functions via using this paintless scenarios and paintless scenarios and set graphics
calls, which I wanted to do. This is why my presentations were a bit sloppy. I was about to
showcase your detection runs, do kind of deal, it didn't happen sadly, but maybe after the fact
I've shared it in the end, but I'll just show you this thing. Like it just follows the mouse,
but in the idea is you can, with this same concept, you can implement any kind of custom UI handling.
You can hook to clicks, drags, whatever you can create a system level, drag and drop as well,
as far as I can see. So yeah, this all from me. Thank you for listening.