This is going to be fast.
This is our sort of content that we'll need to explain this.
I condensed that in like a 40-minute stock that I present to a 20-minute thought,
and I end up with a line in talk.
So let's see what it's going to happen.
What I want to explain is what is the sync package and how it's built.
I can just keep things.
The main thing that you have to know is based in two building blocks.
One of them is atomic operations.
Atomic operations are helping for doing things like adding numbers in concurrent way.
What is doing is basically taking the CPU instructions and say,
hey, take care of that.
So the CPU is taking care of serializing that execution,
and ensuring that there's nothing happening at the same time.
There's no other process modifying the value.
The other thing is semaphores.
Semaphores is not exactly the same thing as semaphores in computer programming
than in single.
But well, the idea is when you have a semaphore, you have a set of buildings
that one acquired the semaphore and the rest.
When tried to acquire the semaphore is going to wait.
The semaphores is the way that the goal runtime has to have for blocking
a goal routines.
So whenever the first goal routine leave the semaphore,
another one acquire that and so on.
So that's all the building blocks that we have.
And everything in the same package is built with two building blocks.
So let's start with wind groups.
This isn't some of usage of wind groups.
Everybody knows how wind groups works.
And this is a structure.
The structure has a state that is basically a counter and a waiter counter.
So a counter of the goal routines that you have to wait to finish.
And the wait counter is the number of goal routines that are waiting.
And a semaphore there.
So whenever you run a goal routine, the main goal routine is going to add three
to the counter.
It's going to increase that.
Then other goal routines come.
The main goal routine starts waiting.
Other goal routines can't wait, also.
And start waiting for the semaphore.
So it gets blocked there.
Other goal routines start doing things.
Doing dawn, dawn, dawn, and in the last one,
also free the semaphore and the main goal routine keep going.
So that's how it's worked.
And then you have the music says that is,
the semaphore was, basically, a lot.
And it's for set some boundaries on setting variables.
And internally, it works with atomic operations on the state that have this
look at, walking and starving and waiter.
But the important thing is going to be the look at one.
The look at is what is saying, hey, this music's look or not.
And the semaphore is used to have control over that.
For example, a goal routine look that.
And the rest of the goal routines is going to see the, well,
actually the look is in an atomic.
So it's going to see that the music's look.
So it's going to wait for the semaphore.
And when the goal routine finish is going to wait,
it's going to free the semaphore.
And normal goal routine that is waiting is going to wake up.
So I'm not going to gain to the things because it's not enough.
So once, once is something that executes something only one time.
And it's built again with all the things.
In this case, it's built with a new text and atomic.
But at the end of the day, a new text is built with semaphores and atomic.
So you have the, you have this, don't, don't.
A structure that is the atomic part.
And then you have the music.
What is going to do is the first time it's going to start doing,
it's going to go through this low path that is going to start executing the,
the function is going to take the music,
start executing the function.
And when I finish, it's a store the data in the dome value.
And every subsequent call is going to execute the,
it's going to go through the first path that is going to check.
It's going to check if it's already done.
And we're doing the same value.
Maps.
Okay, a map is a sing map that is an implementation of a map that can be accessible.
Synchronous.
If you try to do the same thing with regular map,
it's going to panic probably depending on, well, it's not necessarily panic,
but it could panic perfectly.
So you shouldn't do that.
Then it has some new decks.
I have a read-only and a duty map.
The idea is that everything in the,
whenever you load something,
it's going to try to check the read map that is the first copy of that.
And then the duty map is just a set of keys that are amended to the read map.
And thanks to time, the duty map gets into the read map.
And basically when there's so many misses,
because every time you try to load something on it,
you have to check in the duty one is a miss.
So whenever there's so many misses,
you can copy over the read map.
Then you have the store operation.
Well, it's kind of related.
It's going to try to read the entry for the,
and then initialize the duty if need.
Do this unsprung thing.
I'm not going to go down that rabbit hole.
So let's talk about pools.
Pools is somebody already talk about them.
It's for storing variables and reducing variables.
It's a mechanism for improving the garbage collection in certain cases.
And it works in this way.
It has this local cache of variables that have a private,
a private variable that is one entity of the variable that you're saving.
And a share pool chain that is a list of variables that are there.
Then you have the victim pool.
And what it's going to do is whenever you,
whenever you save something, it goes here.
And whenever the garbage collector passes,
it's going to move the pool to the victim pool and clean this up.
And it's going to be used later.
And the next time the victim pool is clean up.
And this one goes here.
And that is going to avoid garbage collection to do a lot of work.
I'm not going to go to all of these.
And then you have the, no, it's solid.
I have 30 seconds.
So.
So then the con is kind of similar to,
oh, it's not similar to here.
We're interface.
So you have to log the thing before you access to the variable.
And then you wait for somebody to signal you that you can check again the value.
And the value is updated by the other side of this.
It's really weird how it works.
And I don't have more time.
So I go into finish here just to say that everything in sync packages
made with add-ons.
And of course, some of course.
And that's it.
Thank you.
Sorry if I'm rude to you during lightning talks,
but this has to move so fast that I do not say please.
If you are talk is go links and go come to here now.
You have less than eight minutes.
And if you're talking to microphone, please do like me.
And almost kiss this thing.
Otherwise sound will not work.
Hi everyone.
My name is Tobias.
And this morning I did not know that I will give a lightning talk this evening.
So I have fourth light.
And we just start.
With some question first.
Who knows what go links are?
Or heard of them before.
Oh, one, two.
So what go links are is I think they came out of Google.
It's like short links, but for co-workers.
So if you have a link which you want to,
or topic you want to know or give for everyone of your co-workers
for example like the Vicki or something,
then you put it on go slash Vicki or something.
Or if there is no go link, then you put a new go link.
And it's a redirect service.
So it's like tiny short nerve.
Part of the difference is that there is a small trick.
Which you are using in such to match.
Which makes it easier.
So maybe we will get back to later.
What is the nice thing about this?
So what go links are?
I told already.
And the basic requirements for go links are that you have a redirect service.
So for example, if someone serves for searches for the Vicki or other things
in your company, then you are redirecting them to the real domain,
which is behind the short link, then you have a simple user interface.
Because one of the principles of go links is that
if there is no go link, the person who thought that the go link has to put it in.
So for example, if someone is searching for a project and it's not in,
put it in so everyone else after you finds it.
And then we have to need to store the data so that we can restart the program
and can redirect afterwards.
And they have the bonus.
And if you do it in your company with DHTP or group policies earlier on
because Windows didn't support this, you can put a search domain on your computers
and the search domain is basically if you have the domain resolution in your browser
for example, you are searching for go.
And it's not finding anything when it's appending of the search domain
and you've got a fully qualified domain name.
And for example, if this is go at Kulboponcom,
for example, and this is where your services located.
And then it's going to do its magic and redirecting everything.
So if you have a look into the source code,
because the fun part about this is that it is an afternoon project
and it helps everyone in your company or in your co-workers
to find everything even for your service good.
So the Vedic part is in my requirements where I need to write it and go
because it's fun and go.
And then the next part was, where do I store the data?
I don't want to have a SQLite and fill with CGO and other stuff.
So there's an amazing project with this called GoBoat,
with this nowadays called BeBoat.
I think the code was for ITCD and ITCD is maintaining this project.
So basically we are having user interface,
it's slept together in a few HTML files.
So there's a basic interface with this is getting served.
We have the HTTP server from the co-site and it's a
some small JavaScript which adds it in the background
to the user has a nice user interface.
So basically I would show it because it's not my computer.
I would have a demo, but it's only a box in the input box
in the middle of the screen and you put in the link
and everything else is not possible.
Because that's the best thing.
It has to be as small as possible.
It has to be easy.
And then in the Vedic part you have some endpoints.
For example, if you want to list something.
So if you ever have the need to see every routes,
you have the possibility for example to have
the registry something like the risk is free then you can edit it
because if something is broken or has changed the redirect
or else then you have a need to change it.
And basically you can save it to a CSV file for
exporting or analyzing.
So the most important part of this part where you say everything
is catch and everything is getting redirected to the start link
and the redirect is basically stored in a key value store
from bold as I told before.
It's a single file.
So no server endpoint is needed.
Bold stores byte to bytes.
So key value.
You search for a key.
If you find the key, you redirect.
If you don't find the key, you show the webpage where the user can input
the goal link.
And afterwards the next user can directly get them.
Well, I think there's no more.
Think to say about it.
Thank you.
If you see your talk being open, I think it's yours.
Just how to mic closely just like I am.
You almost have to kiss it.
It doesn't bite.
Go.
Hello, everyone.
Yeah, I would like to talk about PGX,
Outbox library and transaction outbox pattern.
I'm Nikolai.
I'm based in Helsinki, Finland.
And work for the lander for pre-owned project.
And at the bottom, it's how I ended up doing go.
Started the job.
I see Java Kotlin and now doing go.
So why we need this talk?
Because there is no right problem.
It's not something new.
But imagine you have a service,
deployed somewhere in Kubernetes service A,
which talks to its own database.
Postgres or my SQL.
And then there is service B,
which you need to send once you commit.
Insert update.
Then you need to send the message.
And this is called the door right problem.
Because you need to do two rights at the same time
to the database and to the message broker.
And sometimes it can get problematic.
For example, you commit to database.
But then Kafka, your message broker is down.
I guess every company worked.
They had this incidents where the Kafka was down.
And the message couldn't be sent.
And sometimes it's required for the legal perspective.
And if you place an order in the e-commerce system,
then service B is responsible for sending email.
And if that email is not sent,
then it's a problem for a company and a legal problem.
Okay, sorry for that.
So yeah, basically a transaction.
Outbox button is it's done.
It's introduced this Outbox relay.
It's a kind of additional service.
And the service A, it will try it.
So the posgres it will try the domain entities.
It's responsible for and it will try the Outbox messages
in the separate table in the posgres.
And then Outbox relay would independently read those messages.
It might suggest acknowledge them and publish to message broker.
So this is how the issues of the right problems can be solved.
So this was my kind of weekend project to make this a PGX Outbox library.
Even though it can be done by other solutions.
For example, what a mute provides information.
Provides a opportunity.
So out of the box is library implements.
It has a message.
You have to follow the format and there is a writer,
which can join a transaction to write the posgres.
There is three there forwarder and a publisher to SNS for now.
So the message looks like this.
So you have basically payload is what you want to send.
You can indicate the broker and the topic.
And then some optional metadata.
And then there is a writer, which you can use in your code.
So for the first method, it can support both.
It can support PGX because basically PGX driver is the most famous most popular driver
for the work with posgres from Go.
And the second method, it can do button.
So you can send multiple messages.
And here are some demo screenshots.
So this is how it looks.
So I can impose the first images outbox table.
So it has messages.
Prepare to be sent.
And the second image is tracing of PGX.
So basically, if you want to commit in this example,
the main entity is users.
So then there is a second query which would write to outbox messages in the same transaction.
And then it size it happens atomically.
All it all backs both of them.
And then as you remember, there is our box three way, which would forward the messages.
So basically, I added support for some name.
Now if I approach like polling of the messages and then acknowledge them.
But now I'm working more about this logical replication.
And right ahead of posgres, which is also known change data capture.
And using this library, this is the same person who maintains PGX driver of written and go for posgres.
Yeah, that's basically it for me.
Thank you very much.
Well, my amazing, this assistant is currently trying to exit these slides and open the next slide.
If this link looks like yours, you can come here and you can grab my microphone.
Thank you.
Yeah.
Okay.
So I have a story that happens on one of our PR.
And I decided to show it to you because it was really mystery story.
It's very cool that it's much simpler than this PR.
If you are interested, you can always go to the root cause.
So let's start what is nil.
So nil is typed empty point pointer.
It's my definition, nothing from the documentation.
And how do we check for a nil nest?
Typically something like this.
X is a variable name.
And we do something alternatively you can compare to not equal.
So how does it work on each check on an interface?
Here is some dummy example where we have a is nil function.
If whatever we pass there is nil or not.
And how we can define the variable.
So the first one is of course it's not nil.
It's a pointer for an implementation for interface that we have here.
Super simple.
Second one is actually nil pointer to in interface.
And the third one is a nil pointer for an implementation of an interface.
And that would be important because let's see here.
First line maybe I will run to save some time.
And oh, okay.
So first line returns false.
If you remember A was just a pointer to a variable.
So it's not nil.
Second one is nil because we pass nil.
So not a problem.
And the second one is true because it's nil.
And the third one is nil.
Although we pass a nil.
So that's something contrary intuitive.
Not sure if you ever experienced something like this.
And why this happened?
So when we compare nil nest in go and when we compare anything in go.
We need to compare apples to apples.
So if you compare interface with some direct implementation,
it will not work because the type are mismatched.
So that's why it's not nil.
And what are the solutions?
We can go with reflection.
This is something that we do.
If you go for it, I think that's something like this.
You can find in many repositories or I think I'll stack overflow.
So we go reflection, get value, compare the value, compare the pointer.
Yeah, kind of magic.
But clear is better than clever and reflection is never clever.
So we do not want to have a reflection error code.
So what we can have, we can use generics.
And to use them, we need to have a type that is any.
But we want to compare pointers.
So we need to give a compiler another type hint.
So in my case it's a pt, which is a pointer to this type that we pass previously.
So then we can create that is generic pointer with this varmptpt.
That will be empty, but it has a proper type that we expect.
And then compare it to a pointer that we pass to a function.
A bit complicated, but it's working.
Except when it's not.
So it prevents us from explicitly passing a nil pointer of an interface
without an implementation.
So this var, I, I, is a nil value, nil pointer to an interface
without an underlying implementation.
But in our case, it was not a problem and we prefer to not have this in our source code.
So this gave us another part of security because at the compile time,
we get a check if somehow we pass a nil unimplemented interface.
So that's it.
Thank you.
I promise you could use your laptop if you slice for up in five seconds and he made it.
Yeah, it was your microphone.
Let's go.
Sorry about that.
Okay.
So I'm talking about a project called RIP that I presented last year.
So what it is actually RIP is a project to reduce boilerplate of HTTP
and LERS to get kind of the same behavior between the post-demand implementation
and then to get implementation when the project gets big.
Then everybody does a little bit and not everything and so that it gets in coherent
and it's hard to work with those code based at some point.
So a quick show of hands.
Who was at the my talk yesterday last year?
Okay.
Okay, so my jokes will maybe still hit.
So I'm Tongi, I'm from France.
I worked 18 years in IT.
I was for eight years in Paris.
I worked in different domain in consulting.
Very interesting.
I worked in finance.
I worked in in health health care.
So there were like different stuff.
Very interesting to learn.
I'm also a CEO of HTML.
Okay.
One person got it.
But that was before.
So will it work?
Yes.
So as you can see from this video I'm ready to do anything for money or attention.
And so I'm a freelancer.
So that was my yesterday.
That's why my voice is totally broken and I'm completely wasted.
And this is my first crowd surfing from my life.
So I guess my.
Thank you.
My middle life crisis is hitting hard.
So I was I wanted to life code.
But then March had told me that I couldn't use my or it was written.
It couldn't use my computer.
So I prepared slide.
And then she told me I could use my computer.
But I hate losing hard work.
So you're going to have to deal with my lousy slides.
So let's say we have a project and we just want to do something quick.
We just want a collection of albums.
For example.
So we create our own type.
It's going to be an album.
It has an ID.
Has a name.
The artist of the album.
A really state.
Yeah.
I put a QR code everywhere.
I'm I'm I'm doing marketing.
And so.
The we have our type.
Then we need a database to save that.
I use an ORM.
Okay.
Stop booing.
I know I know some of you would do.
But I'm trying to go fast.
You know.
Time is a.
So I'm using a go.
I'm doing a on escalate.
I do it in memory because I'm metal.
And then we auto migrate.
So then it creates all the tables and stuff that we need.
I use the structure logging from the default from the standard library.
Then this is where I did the improvement in my library.
I created like some already defined provider.
And here I use a go on provider.
So it needs like the type.
We want to create which is an album.
We pass the DB in the the go on database inside.
But you can implement your own providers with your own.
Library that you want.
You can use like database slash SQL and extra.
And I inject also the logger because this is what I use in it.
This is the code that was from last year.
Let me check the time.
Okay.
I'm going to go fast.
So I create a route options where we decide which kind of code I want.
So I want Jason and I also want to generate HTML pages and HTML forms.
So I can dynamically modify it.
Then I pass my function which is RIP and all entities.
My method to actually function.
But anyway to the HTTP and all function from net slash HTTP.
And based on that everything everything will be generated automatically.
That's it.
You listen and serve and it works.
So I guess the full code is that.
It's like 30 lines of code.
And so it's time for a demo.
Okay.
Can you see?
Yeah.
Oh sorry sorry.
No I am your mic stands.
I am praying for this.
Thank you very much.
No I don't see stuff but I don't need it.
Okay.
It's just going to do this.
You could sorry there.
Okay.
So this is my Lousy HTML form generation.
I'm not a form and developer.
So this is my form for a new entity.
I'm going to put well the band that I crout served on.
Which was.
Encepheroom.
Great band by the way.
All right.
And I think they really disalbum 2001.
Let's say we generate it automatically.
An idea.
And I'm going to just copy paste to show the Jason.
That Jason works as well.
So let's see if it exists, which a little bit big.
So here we have the entity that is available.
Let's say now I just want to delete it.
So I need to pass as well the entity.
And I'm going to delete it here by Jason.
And normally if my math is right, it disappeared from the app.
And that's it.
Like 35 lines of code and you can start prototyping.
And so I started using it for real.
And so I'm working on a mobile app.
And I'm starting prototyping like the back end with that.
And as the back end will get more complicated,
I will just remove my provider and create a real provider and change things
so then it's more adapted to the domain.
So here it is.
Thank you.
If you're talking about overtaking APIs, you can come here.
Hi.
Hi, everyone.
Let's complain about APIs.
It's a super minus in, but let's overthink it.
If you pay attention to the previous presentations, you
saw this interface at least two times, maybe more.
But basically, let's imagine you have, like,
HTTP server or whatever, you need to create it,
you need to start it, you need to stop it.
It's simple interface.
Like three methods allows you to do a lot of things.
It allows you to create something to,
initially, some things before you start everything,
then to stop it.
But sometimes, I mean, oftentimes, you also need to do
some visual tribination.
And then you're forced to do even another method.
Or create some ugly things, like, stop and wait.
That's totally fine.
But can we do better?
What if we could use some very modern things that go as
since forever called context is and just use a context?
Then, just with one simple methods,
we can do everything we could do before.
So, we can have some code,
which we run when we want to stop it,
and we adjust the console context.
We can do some methods, which do one running things.
We can do clean up.
And we also can do some things we couldn't do before.
For example, this function that you see can indicate
the color that the whole application can stop.
And because you now have not a fusion interface with
a lot of methods, it's super easy to combine the things together.
So, that's just copy and paste code.
But basically, you just use error group,
which is in the experimental package in Golang.
And you can just shuffle them together and then combine them together.
So, now, not only you have a simple interface,
you have easy ways to combine the things and run them together.
And another advantage is if you don't care about the execution order
or a combination order, you can also create some kind of trees
of those routines.
So, if your application is like 20 of those things, it's super handy.
And yeah, and raiseful termination is also super simple and
pluggable.
So, if you standardize the things and you have a lot of apps,
you can just use that.
And that's it.
Thank you.
I have two more to go.
If you can make it fast, that will be amazing.
And let's go.
Hi.
So, quickly, I am a go-far for 10 years,
and I built a scale where I met March,
Bertie, we have some people in the room and no Gno.
And as you can imagine, Gno is rated with Go.
What is Gno? Gno is basically a variation of Go,
which is built for the strizer applications.
So, it looks like Go, but it won't run the same way.
While Go is a compiled language,
that you will run on several servers.
Gno is an ecosystem, including the runtime,
the long-range and racing.
So, in one sentence, Gno is a transactional VM.
So, virtual machine, it's not compiled.
It will execute interpreted code.
Transactional, because you don't find a demon for your applications,
but you can make transactions against the set of applications in the VM.
It allows to write decentralized application,
which is not possible in Go, because Go is not deterministic,
and it's not safe enough for what we expect to run on this ecosystem.
And it has some built-in features that are not possible in Go,
such as state persistence and safe execution.
So, this is a simple Gno code.
It looks like Go.
The thing you can see is that basically it's not package main,
but package LO, and it does not have a function main,
but a fake LO, which is exported.
So, basically, this application is something,
allowing anyone to query the LO function against this contract.
Basically, you run Gno code on GnoLand.
So, GnoLand is the equivalent of AWS,
instead of publishing your binary on AWS,
you publish the source code on GnoLand.
Instead of writing in Go, it's in Gno,
and it's not an application, but to decentralize application.
We have several changes.
At the end, it looks like Go, but, for instance,
we won't interact using JSON, GRPC, and everything.
Instead, we expect people to call Go.
So, the API is not JSON.
The API is Go.
You call a function with parameters.
We don't have microsialices.
You don't open a connection to another Google program.
You import it.
So, once you import something, you don't once again use GRPC or whatever.
You import something.
You use the structure, the functions, the method, and everything.
We don't have RNs or DB.
But instead, we just use automatic persistence,
that you will see after is basically using global variables.
We don't have dependencies,
basically you need to upload the resting on the same VM.
There is no way for the VM to fetch something from the external world.
You need to upload all your dependencies.
All the dependencies are persistent.
So, if you build something and deploy it on Gno, it's air forever.
There is no byte code, because we upload the source code.
And by uploading the source code, you have automatic source code viewing.
So, it's very transparent.
But it's also allow you to interact with the contract,
but also import them.
So, when you write an app, it's an app and a library.
An advanced example showing is the automatic persistence.
So, here you have a container, which is a global variable.
It is a transactional VM.
Each time someone will call increment, it will increment the container.
Save the container.
Save the state.
And each time someone calls it again, it will load the product state.
Apply the change and save it.
And that the same for the render, which is a redundant function,
that will fetch the state from the automatically.
So, here's another advanced example that I will deep dive.
Basically, this is a mini social network applications.
So, this is a decentralized one.
You have first something which is very similar to go.
I think this is called, except for the STD import, which is specific to go.
This code is basically purely go.
You declare a new track share.
It has a time dot time.
So, not to primitive type.
STD address is something internal to basically give you run time environments
such as the caller, the author, or the UAD in the web2world.
And as you can see, we can extend the track shares as in go
to, for instance, return an advanced string.
And this is the rest of the contract.
So, here we have a collection of posts, which is perceived systematically.
We have a create post, which is the first function that anyone can call
to append a new post of the type post with a text,
which is provided as an argument.
Also, which is automatically get from the runtime environment.
And create the add, which is with the current time at the time of the transaction.
And then the render function is a randomly part.
You call it, actually render something special,
ignore that will automatically provide a web interface,
compatible with Macdon.
And here you just list the post, and for each other then you
display the post ID, and the post stringer.
So, these two files together, you upload them and you have this social
application.
So, first screenshot is when you just deploy it.
Then we make a transaction.
So, we are using like CLI wallet to call the track post with an argument.
And when we refer to the contract, you have the new post that was dressed
at it.
Something interesting when you have an interpreted code instead of a
compiled one is that you can import the contract.
So, Alice is a persistent code with just a geter and a seter,
and Bob can import Alice.
And as you can see, Bob can get the value, increment it,
and it's saved.
So, you have like libraries, but each library has its own state,
which is also automatically persisted.
So, you can imagine having a post, which is imported,
and the other contract will compose or extend the micropost.
And to conclude, what we tried and what actually succeeded to do
as to make goals and language we all know here,
the good language to write this under the application,
without changing your habit, without having to understand all the
blockchain states will work.
Instead, you write your code with pure Gology,
with actually less non- Gology because you don't have
JSON or my SQL or whatever.
You write your code and you have a decentralized application.
And if you want to contribute, it's an ecosystem of
contributors.
So, please contribute.
Thank you.
We have two more talks to go.
I just are one last minute.
Okay.
I added myself as a lot one.
I can do so.
Great. Hello, hello.
My name is Leandro.
I'm not German, but I live in Germany.
Anyways, it doesn't matter.
That's my talk.
I made it like leisurely.
Two hours ago.
So, it's really improvised.
It types directly called Gology.
So, there's loads.
So, probably doesn't even compile.
But let's see.
So, next call is called self.
It's a pattern.
I don't know if there's a name.
So, I want people to let me know how this thing is called.
If there's a name.
Anyways.
Yeah.
It's not really a good topic.
It's more related to programming.
I'm not on Gology basis, so that's why I'm here.
So, a really bad example.
Because I was really not really creative for writing examples.
So, I have like here function.
It's really bad to see.
Anyways.
Can you see?
Well, is it fun?
No.
It's not.
Yeah.
Okay.
No, it's just like HTML.
Can I make it like black or dark mode?
Maybe can convert it to colors?
Also, it's explain.
So, there's like function here called fool.
And it has like some helper functions instead of it.
So, we have like two variables here.
Local variables.
And those functions here.
Inside my, my fool, they basically handle those variables.
And like.
Okay. Yeah. That will help.
Okay.
This is better.
Okay.
You can see here some some variables here on my function.
Some helper functions.
Don't care about the constant of the functions.
It's really like doesn't matter.
But you see that those functions they use those variables here.
So, I have something being done here.
And some actual code that uses those two inner functions.
So, in a traditional clean code object oriented way, what you would do is,
like to create a helper class or in our case, a struct.
Put like the state and some of it.
Instead of like having this free variables.
And you have would have some private methods.
So, my helper functions would become.
So, called like private methods.
And my behavior would be on a public.
I will highlight again.
My public behavior would be on a public method.
So, called.
So, yay.
It's object oriented.
And it's much cleaner, it's better.
Not really.
But.
So, this is how it would look like.
The so-called like clean code version of it.
And I'm not saying that I agree.
I'm basically saying that you know.
That's what it would be said.
So, it's still at some time.
So, yeah.
Great.
So, my point is that I saw like some kind of equivalence between the two different approaches.
They weren't using like an extra class or struct to encapsulate the, you know, private and public behavior.
But here we don't have this.
We have, you know.
My scope is being used as self in my class.
So, there's like this implicit self which is the scope itself where those two variables here, which are the state where they are.
And we create like this behavior of private and someone by capturing them into the two functions.
That's something.
Which I have seen like multiple times, but I don't know how this thing is called.
So, that's why I'm asking you all to name it.
So, bottom line.
The two approaches of their equivalence, they behave the same way.
Okay.
So, as I said, my scope is the self or these depends on the programming language that you're using.
I guess, of course, the receiver of the methods of the, of the, the message call.
Yeah, and we can use the, um, those like three variables in the function as the state.
Um, I don't know how this thing is called if there's a name.
So, that's again.
Please, the elephant, you know, this thing has a name.
I don't know, I don't know whether it's a good practice.
I know that it's being very useful for me.
There is no official name, but there is a sentence under which this is known.
It is called closures are poor, poor, cement objects and vice versa.
Okay.
So, that's a good name. Thank you a lot.
So, um, yeah, so probably not good practice, but it's being useful for me.
Um, so one of the issues.
I, I don't know much about the go home pilot, but, um, will the go home pilot just like move things to the heap, just because the work captures captured captured by those, um, those functions.
I don't know really. I haven't really banked my benchmarked anything.
Um, so it also like leads to very long functions, um, which might be good or not.
I don't know.
I don't know, um, long official rather than smaller ones because it prevents me of jumping around.
But, yeah, just as one example, which I have here from, and how do I open this, it's a link, okay.
Um, some code based from sometime ago.
So, I have like this function here, which is quite long as you can see, but it's, I'm almost finished.
Um, I have like some some stage here, and I have a lot of like, so called like my private methods, which are just like free functions here.
And, um, I just have them inside of like the outer function.
And I essentially use them in different places.
So, it's a very long function that, you know, is doing, I think, a lot of bugs here, but no, I don't care about the bugs that much.
So, yeah, basically, um, that's the thing I wanted to, to show that this, this kind of approach has been useful for me on some code basis.
It kind of emerged that I didn't really plan, but it was there.
And yeah, so the question has been answered already, so that's it. Thank you a lot.
Thank you.
I don't know how to actually hear us all just do it like this.
I got one last minute submission for the Lightning Talks, which was from a girl called Marcha.
I know her well, so I decided to give her accept her talk.
This morning I gave it to all the states of Go.
Today I'm now the end-giving, the last talk, this state of Marcha.
Thank you for starting the timer for your own boss, Nessim.
I want to thank you.
I want to thank for them specifically for making sure we have this room, for making sure we get to be here,
for making sure that everything works.
Thanks a lot.
I'd like to talk all my volunteers over there.
The first row, the ones who already have our going for dinner.
The ones who are helping us stay in the cleanup.
Thank you. Thank you very much.
I'd like to talk to you. Thank you for attending.
You have might have been attending for all 11 years.
You might have been attending for the first time.
You are what keeps me going.
If you weren't here, I wouldn't have done this.
Please keep that in mind.
And now in my actual state, I am tired.
Noticeable?
Really, really tired.
My personal life, simply said, complete mess.
I worked on this dev room, for ever since the CFE came online, September something.
I worked on it from multiple hospitals.
In multiple stages, I had my laptop, my phone.
I was like, okay, I need to send out emails.
I need to get phone, please going.
I need to advertise CFP's.
In whatever mental physical state I that time was,
be sure it's not normal, but I kept going.
I might even have been standing here today.
So I want to thank everyone.
I really hope you appreciate my work as a volunteer here.
Thank you.
I'm not being paid.
I don't have any sponsors like for them.
I don't even have a free hamburger to go home on.
I have to pay my bus to go to the Lair.
So I really hope to see you all next year.
And this is a general notice to everyone in this room.
If you can, volunteer.
Here, everywhere somewhere else.
The world is miserable.
And we all need some volunteers to make the classical Silicon Valley dilemma of.