 Hai, semua. Saya Jensie. Saya seorang pelajar di Singapura University of Technology and Design. Saya akan berada di atas kawasan ini. Saya tidak mempunyai banyak pengalaman, tapi semoga anda dapat belajar sesuatu. Ini adalah kandungan saya yang terkenal. Saya rasa salah satu sebab saya bercakap dengan hari ini adalah kerana saya mempunyai pelajar di bawah ini yang saya belum bermula sekolah. Saya tidak berat dengan salah. Tapi... Saya terlalu lewat untuk itu. Jadi, ia sepatutnya untuk... Ia sepatutnya untuk untuk 5 tandaan rambut. Tapi, saya rasa saya tidak dapat berada di atas kawasan ini. Saya hanya akan memberikan tiga tandaan. Dan semoga anda dapat melakukan lebih banyak tandaan untuk setiap tandaan. Okey, jadi tanda pertama. Pembalasan mengenai prox dan lambdas. Sebenarnya, saya rasa tanda ini... Saya sebenarnya telah mengenai pembualan mengenai prox dan lambdas. Tapi, lebih banyak saya mencari, lebih banyak saya menjadi tanda. Sebab saya hanya memilih lebih banyak tanda. Dan saya rasa anda akan faham sebab saya akan mencari. Okey, jadi... Pada pertanyaan alam ini, prox dan lambdas. Pertanyaannya telah diberi dan menjawab. 10,000 kali di luar di blok-blok. Di segalanya. Jadi, kenapa orang harus menjelaskannya lagi dan lagi? Untuk orang lain. Kemudian... Kamu tahu kenapa, kan? Sebenarnya, kamu menjelaskannya kenapa? Apa yang menarik di Ruby? Jadi... Pertama saya berfikir, saya hanya begini memprogramkan. Mungkin ada beberapa perbezaan tinggi, perbezaan antara prox dan lambdas. Saya tidak memperkenalkan, tapi saya terlalu lezik. Jadi, saya hanya menjelaskannya di listan untuk memahami Ruby. Sebelumnya, saya tidak menjadi lezik. Dan saya memperkenalkan. Sebenarnya, ia adalah perbezaan yang sangat gila, perbezaan yang sangat berlezik. Saya rasa ia sebuah pembualan yang teruk di Ruby. Saya rasa Ruby membalas sesuatu yang saya suka. Jangan membuat saya memperkenalkan perkara-perkenalkan. Jadi, ini sebenarnya dibuat dari pembualan 8Flight yang bercakap tentang... Apabila anda membuat pembualan untuk orang, seperti... Pembualan yang akan memperkenalkan. Anda tidak membuat orang memperkenalkan perkara-perkenalkan yang tidak perlukan. Dan saya rasa perubahan antara prox dan lambdas adalah salah satu perkara yang tidak perlukan dan perkara-perkenalkan yang tidak berlaku dengan Ruby. Jadi, perkara-perkenalkan ini... Prox mempunyai perkara-perkenalkan. Pertama saya mempunyai perkara-perkenalkan. Katangkan mesej dan mengarah ke lambdas. Untuk apa yang akan saya berpura-pura? Contohnya saya nak membuat pembualan yang baru semasa, bendsunyai brown dan lus rather semula. Saya tidak ingin membuatnya prox dan lambdas untuk seesar protest dan selamlanya. additionally, begitulah pembualan, perkara-perkenalkan How Of The Prox. Pt. ab kak rai di Ruby. Jadi perkara-perkenalkan anda memb煮camemba bersama k simplified, p tensik membuat yang dark. Atau, dengan rubi 1.8.7, pembualan ini tidak p installing. Tetapi sekarang mereka melakukan perkara yang sama, maka kekal. Kemudian linda prox, saya akan mengeluarkan linda prox yang tersebut, yang tersebut adalah lindar. Ini juga adalah kemahiran dari kemas prok yang kamu mencubanya dengan kanol linda, atau dengan sifat jelah romantik. Jadi, mari saya jelaskan kenapa saya menerima kemahiran linda prox. Jadi, saya mengelak kemahiran linda prox. Kerana seperti yang saya katakan, mereka hanya kemahiran dari kemahiran prok. Dan mereka hanya kemahiran dari kemahiran prok dengan sesuatu yang bertambah seperti lindar flag dikatkan ke. Dan sebenarnya, jika anda lihat di sini lamda saya dan saya menghidupkan, anda sebenarnya melihat, saya tidak tahu jika anda dapat melihatnya, anda sebenarnya dapat melihat bahawa ia adalah objek prok dengan lamda di bawah sana. Dan sebenarnya, prok-klas itu mempunyai masyarakat lamda, yang menerimu jika ia adalah lamda. Jadi, ia adalah objek prok dengan pukul lamda ini yang benar-benar yang benar. Saya cuba mengingatkan diri saya dengan ini dengan menghidupkan prok lamda. Jadi, apa yang doktor mengatakan? Doktor mengatakan bahawa ini mempunyai lamda, ia adalah percaya untuk apa yang mereka panggil, tukar. Ini adalah perkara yang teruk, saya bermakna biar saya menjelaskan. Jadi, ia menerimu jika tidak ada tukar, menggunakan. Okey, jadi apa ini? Apa ini tukar yang hebat? Dan saya akan menerimu lagi, tukar ini tidak baik. Jadi, saya rasa anda patut hanya menggunakan tukar, tanpa prok. Okey, mari kita lihat. Tukar pertama. Saya mempunyai prok dengan tukar. Saya membuat sesuatu yang panjang dengan tukar pertama. Saya mempunyai dengan tukar kedua. Di tempat jauh-jauh di tempat jauh saya, ini berlaku selama-lamanya. Saya membuat pembentangan, saya lupa untuk menghidupkan tukar kedua. Apa yang saya dapat? Biasanya saya dapat tukar, tapi apa yang saya dapat? Saya dapat tukar tukar. Tidak ada tukar dari tukar ke tukar. Kemudian anda seperti, okey, saya sepatutnya menunggu tukar tukar, tapi saya tidak. Ia tidak sangat bantuan, ia seperti kriptik dan tidak bantuan. Tapi jika anda melakukan perkara yang sama dengan lamba, kemudian, ya, anda dapat sesuatu yang menjadikan, anda dapat kesilapan. Beritahu anda bahawa anda mengambil banyak kesilapan. Okey, itu menjadikan. Tapi bahkan lebih teruk daripada kesilapan kriptik yang proks beri anda. Ia adalah kesilapan yang berlaku, mereka berlaku seluruh. Jadi, apa jika saya mempunyai prok seperti ini? Saya membuat peribadian kemenangan dan saya menggunakan penjara ini. Saya suka peribadian kemenangan dan saya tidak suka peribadian. Jadi, peribadian yang berlaku akan menjadi sesuatu seperti menggunakan peribadi, tapi peribadi. Jadi, saya suka peribadi, tapi saya tidak suka peribadi. Dan anda tidak sepatutnya suka mereka juga. Sekarang, seseorang yang tidak familiar dengan prok saya lupa bahawa dia sepatutnya menggunakan penjara. Jadi, dia menggunakan peribadi dan peribadi. Dan apa yang saya dapat? Saya suka peribadi yang saya tidak suka. Dan ini sebenarnya grammatik saja, tetapi ini oksimoran, bukan? Dan keadaan ini berlaku seluruh. Ia tidak akan menyebabkan keadaan untuk anda. Kerana apa yang berlaku adalah prok ini berlaku seluruh menyebabkan keadaan untuk menyebabkan keadaan untuk keadaan. Dan jadi, keadaan hanya dapat dikeluarkan. Dan itu adalah pilihan yang pertama. Prok adalah keadaan untuk menyebabkan keadaan. Dan untuk saya, saya tidak tahu mengapa ini akan menjadi pilihan. Kerana ini hanya akan menguruskan saya sebagai programa. Jika saya menggunakan keadaan, saya berharap untuk menggunakan keadaan. Saya tidak berharap untuk menggunakan parameter saya dengan keadaan. Saya dapat lebih baik daripada itu. Oh tidak. Okey, maaf, anda sudah melihat itu. Jadi, saya ada prok yang lain. Sekarang ia mengambil A dan B. Dan saya berharap A dan B untuk menjadi pilihan. Jadi, saya menggunakan pilihan. Pada pilihan yang benar, saya mengambil dua pilihan. Tapi kemudian saya juga lupa mengambil pilihan kedua saya. Sekarang saya tidak mendapat pilihan. Saya mendapat pilihan yang tidak mendapat, pilihan yang tidak mendapat untuk mengambil pilihan. Dan tentu saja, jika anda menggunakan alam dah, anda dapat sesuatu yang dikatakan dengan pilihan pilihan. Dan anda melihat alam tadi. Alam tadi adalah, ia mempunyai alam-alam jika ada alam-alam lagi. Dan sekali lagi, ini benar-benar mengambil saya. Kenapa saya perlukan alam ini? Kerana jika saya benar-benar ingin mempunyai alam-alam, saya hanya dapat melihat alam-alam. Tapi, ya, sangat membantu. Jadi, ya, saya tidak faham alam ini. Jika sesiapa yang faham, kenapa alam ini mempunyai alam-alam. Jika sesiapa yang faham, saya akan mengambil alam ini. Jadi, kerana Ruby memperkenalkan semua kompleksi ini dengan alam-alam, sekarang kita perlu bercakap tentang alam-alam alam. Apa maksud saya? Jadi, kita tahu kita dapat menggunakan alam ini. Kita dapat menggunakan operator M% untuk mengubah alam-alam dan alam-alam menjadi alam-alam. Yang juga bermakna saya dapat mengubah alam ini. Saya dapat mengubah alam yang mengubah alam ke dalam alam-alam atau alam-alam. Jadi, masalah saya kepada anda, adalah alam-alam dan alam saya yang mengubah alam? Siapa yang fikir? Tiada siapa? Okey, alam dan alam saya yang mengubah alam? Ya. Siapa yang fikir alam dan alam dari alam-alam? Jadi, anda dapat mengubah alam alam menjadi alam. Jadi, siapa yang fikir alam ini adalah alam? Jadi, semuanya bukan alam, anda fikir alam. Okey, jadi jawapan adalah alam, tidak alam, tidak alam. Okey, jadi, anda mungkin fikir apa yang saya sebab? Alam saya sebenarnya adalah alam yang mengubah alam. Anda mengubah alam, ia masih lucu. Saya tidak sedih untuk bersenang. Selamat-menakjub. Alam saya tidak lucu. Bukan perkara yang menarik itu. Saya menunjukkan sekarang. Anda mengubah alam, dan melamannya ke alam lelaki. Ia masih akan menjadi alam lelaki. Ia tidak akan menjadi lucu. Sama dengan alam dari alam. Jadi, alam alam menjadi alam muda terug lelaki. Dan jika anda mengubah alam, ia sedih tidak lucu. Jadi, anda seperti, Saya melihat sebuah pattern di sini. Adakah operator M% selalu mempunyai peraturan? Sudah tentu daripada pertanyaan yang anda boleh beritahu, itu bukan selalu kes. Jadi saya akan memberikan ini kepada anda jika anda tertanggungjawab. Periksa doktor. Ia selalu mempunyai peraturan. Kemudian ini, dan ia benar-benar menarik apabila saya mencari peraturan itu, saya sudah seperti, ia seperti pengalaman yang tersebut, bahawa ini semua keadaan yang tidak sepatutnya. Ya. Jadi, itu peraturan. Tetapi kami juga tahu, anda juga tahu bahawa ada perbezaan dalam semantik kebetulan untuk proks dan lambda proks. Dan sebabnya, saya rasa, kerana, anda tahu, biasanya apabila kita berjumpa dengan proks, atau lambda proks, kita fikir bahawa kita sebenarnya berjumpa dengan objek fungsinya. Baiklah. Ini adalah peraturan dalam peraturan yang anda boleh meletakkan. Dan, ya, ia benar-benar benar-benar menurut saya. Jadi, bagaulah, jadi bagaulah, jika saya melakukan ini dengan proks, saya mempunyai peraturan semangat syarikat tergantung Tetapi, lamtas ditunggu... ...dia berpunyai seperti yang ditunggu. Apakah lamtas lamtas ditunggu, lambang lambang lambang akan ditunggu, kemudian lambang lambang akan ditunggu. Lain kali saya mencari perbezaan ini... ...dengan semantik semantik ini, saya diterima mungkin saya hanya mempunyai... ...selepas itu, tapi saya tidak faham kenapa. Jadi saya sedar saja sebab... ...mencari perbezaan ini, sebab... ...dan tidak dapat menerima kemahiran dari procs. Apakah anda menerima kemahiran dari apabila anda menerima procs? Anda menerima kemahiran dari fungsi dan tidak menerima procs. So, in fact, if you do something like this, you try to return from a prog in the top level. This doesn't work. You get a local jump error. You can't return from something that's not a function. And that's the key point. A prog is actually not a function object that you think it is. Most people, I assume it was a function object but apparently it's not. So you can't return from something that's not a function so you cannot return from a prog. You can only return from progs when they are enclosed by a function. So, this is why this last method, you can actually return from this prog. So, this is actually kind of dangerous because we can try to return from progs when it's actually not possible. So, let me tell you again, lambda progs are the ones that are saying they return in an expected manner. So, lambda progs are your real functional object which leaves you to... which leaves a question, so what the hell are progs? So, I kind of figure out from all this explanation that progs are kind of like this weird halfway between blocks and full-flash function objects. So, you can do a lot of stuff that you can do to progs that you can't do to blocks. For example, blocks don't have a name, right? Progs have a name, you can pass them around. You can try to return from progs when you actually can't. A block is kind of static. If you put it in a function, it will only ever be there. But progs, you can kind of try to move it around, move it outside a function and try to return when it can't return. So, that's dangerous. And of course, you can show yourself in a food with all those fancy tricks that I'll show you just now. So, I realised more and more as I thought about this. And this is kind of an understatement. Progs are more like these super power killer zombie mutant blocks and I don't know why you want to use them, basically. And so, I don't know whether... I don't know if anyone can convince me why I want to ever use progs, but I think you should always... you basically always want to use lambda progs from what I understand about what progs and lambdas do. But the sad fact is, I don't know why Ruby wants to introduce progs. I don't really understand. I don't really know why. If anyone knows why, anyone has talked to Ruby called like, why does Ruby have progs? Please let me know. So, yeah, I basically think that you always want lambda progs instead, but Ruby doesn't want to help you because, okay, we saw the ampersand operated just now to convert progs to blocks. We also know we can do the conversion the other way. So, we can... This is a very common pattern. We have a method that takes in a block and it converts the block to a prog with the ampersand. So, the golden question is, is this a Trixie? Is the converted block a Trixie prog or not Trixie prog? Any guesses? I see some strange faces. Okay. Okay. Yeah. The sad thing is, it is a Trixie prog. It's the prog that does all the really weird stuff. And this pattern is very common and I think sometimes this can give rise to unexpected behaviour for people who don't really understand what's the difference happening between progs and lambda progs. And the sad thing is, like I said, the ampersand preserves Trixie-ness. So, once you're Trixie, you're forever Trixie. So, once your block is converted to Trixie prog, you're never going to get back a pure nice lambda prog ever. And yeah, this is a real issue that I found. I mean it's quite old, but the issue, you guys can look and they're interested, but this issue arose because people are trying to return from progs when you can't return from progs. So, they were getting like local jump error. So, originally, they were passing a block to some active record callback. And originally, that block was eval and was like class instance eval into a method. So, methods, you can return from them fine, but after that, they changed active record or something, and then they stopped instant-developing stuff. They just changed them to progs and called the progs. But these progs were Trixie progs and you cannot return from Trixie progs. So, everything broke. So, the fix was to pass in the block, not as a plane block, but to pass it in as a lambda, converted to a block. So, if you convert the block to a lambda and you convert that block back into a prog, it's going to be a lambda prog. Okay, so, I think this can cause, like, definitely can cause bugs. So, yeah, to summarize everything, I compose this little knee for you. So, say no to Trixie to lambda. Say no to Zombie Mutant Block, say yes to the true function objects, and do not return from blocks and mutant blocks. Okay, so this has to be qualified. So, obviously, if you know that your block is a true function, then yes, feel free to return because you obviously know that return is returning from the function, it's not returning from the block. It doesn't make sense to return from blocks, right? But the thing is, people think that you're returning from a function when you're returning from a prog, but you're not. Progs are not function, are not full flash function objects. Okay, so say no to kernel prog and prog.new. Say yes to kernel lambda and the rocket syntax, and thankfully Ruby made it very easy to use the rocket syntax. So, you know, go ahead and use it, type less. So say no to Trixie Ya. Ya, so that was tip number one, a bit of a rant. Sorry. Ya, this is why I cut down the three tips. Okay, moving on. So, tip number two. Okay, so, I'm a Singaporean. Ya. And Singaporean supposed to like our curry. We like our curry so much that we use it to fend our, you know, I don't know, depending on how you look at it, you know, phobia, our national pride. And even write plays about curry, right? So, I realised recently that as a programmer I have even more reason to like my curry. And then for those of you who maybe are not exposed to functional programming or super new to functional programming like me, and who grew up in a place where curry sounds more like something you put in your stomach than your coat, you'll be looking at this curry chicken and you're like, actually talking about, okay. So, it turns out that function curry is some, this concept from functional programming. And in Ruby, you can actually, there's some, some programming tricks. So, there's actually a curry method on the prog and method classes. So, what is function currying? So, I've just blatantly ripped this on Wikipedia. Currying is the technique of translating the evaluation of a function that takes multiple arguments into evaluating a sequence of function each with a single argument. So, currying is related to but not the same as partial application. Okay. It takes XYZ3 arguments and returns a, returns W. If I curry this function, I'm basically going to get a function that returns a function. So, curry, the curry function takes one argument, it returns another function. That return function also takes one argument. It returns another function and that last function takes one argument finally evaluates to the number. Okay. So, that's function currying and this is, now terminology is erity, basically the number of arguments that your function takes. So, erity function is erity one. Dan, what about partial application? So, partial application is related concept. So, you have XYZ again. So, if you partially apply XY onto that function, you're basically binding the first two arguments XY to some value. You're binding the first two parameters to some value and then you get you get a function that takes in one argument and returns, finally, with reduced erity. That means it takes in less lower norm arguments and the original function finally returns its value. And the erity of the partially applied function, so number of arguments it takes is, it depends on how many arguments you initially bind, but in the end it's reduced, erity is reduced. Okay. So, this seems to be very common on internet like currying and partial application that are usually almost conflated, like referred to similarly and I think the reason for this is, I mean, I haven't been using this that much myself, but I think the reason we're just there support currying, they actually also you can actually do partial application with curry functions. So, let's take a look at currying and Ruby. Okay. So, I already explained why I'm only ever going to use lambdas. So, I declare my lambdas it takes three arguments, A, B and C. So normally when I invoke this lambdas I'm just going to pass in three arguments. So in this case I pass in one on one, evaluates to three. But if I curry my lambdas, I can actually basically invoke I can basically invoke it three times. So I pass it one argument each time. So I lambdas.curry 1.1.1 that eventually also evaluates to three. But what is happening in between all these invocations. So lambdas.curry itself returns another lambdas. Right. And this lambdas is a curried lambdas. So when I invoke that curried lambdas with one argument I'm basically binding the first parameter to that first argument. And that returns me another curried lambdas. So that's actually partial application. I'm partially applying lambdas. I'm binding the first parameter to an argument. And then I can do this. I change this until I pass in enough arguments and then my curried lambdas finally evaluates. Right. So when my lambdas originally took three arguments when I finally pass in those three arguments it can finally evaluate. And you don't actually even have to call these only pass in one argument at a time. So like I said when curried functions they should only have arity one. But actually the Ruby curry method actually supports direct partial application so I can actually pass in more than one argument straight away. So if I pass in lambdas.curried.1,1 I'm basically basically binding the first two parameters to one and one. So I get a function that only takes in one argument finally. Ya. And I sorry I have to rent about prox again. They have some very weird behavior when it comes to curring. So apparently if prox you can pass in argument to the curry method. Which doesn't really make sense to me. So apparently if you pass in one to the curry the prox will try to the curried prox will try to evaluate after you only pass in one argument. So I have this prox that originally takes three arguments and I try to and then I curry it with I curry it and say that you should evaluate after I pass you one argument. So I pass the curried prox in one argument and then it tries to evaluate obviously it's going to fail. So I don't really know why I would need this. And then you can also pass it you can also ask it to curry to evaluate only after a number of arguments that's greater than the number arguments actually needs. So if you pass in four to curry and then you call one three times it doesn't evaluate yet. But then if you pass in another argument then it finally evaluates. But then the final argument I don't really know why you need this. So if you try to do this with lambdas obviously there will be an error thrown and I think that should be the expected result. So basically you should never call curry with an argument. You don't need it anyway. Alright. So what about currying in the real world? So the example I'm going to show you is doesn't really use rubies built in curry but it's it's an application of the concept of currying. So I think it's kind of cool to look at. Okay. So this is actually from the dry logic gem. So this is the gem that allows you to do predicate logic and it's actually the basis of this gem called dry validation. Gem used for rich validations. So this rule class actually uses actually defines a curry method. So you pass in some arguments to this curry method and then it combines the new arguments with some original arguments that were stored. They are stored in this instance. So this arcs here is actually accessor for arguments that are stored in this instance. And so obviously if the number of arguments is not correct then you raise the argument error. If not it evaluates this branch and what this does is actually returns it actually returns a new instance of this rule class with the combined arguments. So this is actually a concept of currying and this is useful because sometimes you cannot pass so for example so you actually see them use the curry method here. So this predicates greater than basically returns this object this instance which can be curry. So this returns a greater than predicate. So you pass in the first argument to this predicate object. You pass in 18. So 18 is the value that you compare this greater than 2 but you don't have the data you need you want to compare to yet. So you pass in this argument first and then the data so in this case the actual data being the user's age then the function the greater than function will actually evaluate. So that is one real-world case of function currying. But this is not actually this is not using Ruby's built-in curry methods but it's basically the same concept. Okay, that's all for our currying. So the last one is kind of like a more productivity tool tip. So Vim, Universal C Text slash Reaper Text plus Ruby. The main thing here is actually not Vim or Ruby. It's actually C Text. So how many of you actually have used C Text? Okay, so yeah, so some of you have heard of it. So basically what this allows me to do is have IDS code navigation but in my editor and let me just show you how it actually you saw me kind of using it just now. So when I was trying to navigate this dry logic gem I actually have this text for and Vim has built-in tagging support but of course if you use lots of text editors also have built-in tagging support so you can use C Text with whatever plug-ins that your data support. So I can actually jump to the specific text with some key bindings in Vim. So if I am curious about this model I can jump to it and just now I jump to the curry function and this is very useful for navigating your own projects and there are several Vim plug-ins as well as RBNV plug-ins and gems that allow you to not only generate text but generate text for the gems included in your project so you can basically jump to the gem source and this is very useful when you need to debug stuff and I especially I found this super useful when I was so I'm using trailblazer cells in my Rails project and this is for view models but I had to debug a lot of stuff for this because some of the stuff in Rails doesn't really play well with Rails and it was very helpful for me to be able to jump straight into my gem source whenever I needed to to find out stuff so I can basically just jump into a gem source and see what see what stuff's happening Ya Ya and I mean previously I was actually like using github to read people's like gem code which is okay but it's really terrible like I didn't want to read code after that it was so excruciating especially in Ruby because you have it's OO right a lot of in direction a lot of delegation you jump a method like method calling method calling method so I found this super helpful because you can just and make make debugging code so much faster so okay just go through quickly what are the individual components so universal c-tex so original c-tex program was generated fast for only c c source and headers then there came exuberance c-tex but this is the newest version of this was only in 2009 so universal c-tex is the currently actively maintained implementation so you should use that instead of exuberance c-tex for some reason or another every single blog post out there about Vim and c-tex always ask you to install exuberance c-tex so don't do that go to universal c-tex GitHub repo and install it there's a tab for homebrew go on a Mac there's you can build from source if you're on Linux yeah so use universal c-tex but the thing is because on Ruby we're using Ruby right universal c-tex it does exuberance c-tex didn't have a very good Ruby parser was written in C universal c-tex does a better drop and one thing that I find that was really bad for missing out was aliases so there's one time I was going through action view source and I was trying to find this method but when I opened my tag file it was not there it was like where's this phantom method I kind of find it so apparently it was actually an aliased and exuberance c-tex was not picking it up so universal c-tex also doesn't pick up aliases unfortunately but there's a gem called it parser Ruby better than whatever parser universal c-tex so you can actually install this gem and use it to generate your text instead of universal c-tex okay so Vim for those who use Vim while you have tagging support out of the box you have nice key bindings jump to any text or you can get a list of matching text or you can pop from your text tag so super handy but you need universal c-tex to generate c-tex obviously and Tim Pope the maker of plug-ins has written a lot of plug-ins one of them is rbnv c-tex so this will generate c-tex for your Ruby standard library automatically on install as for gems so if you want better text use ripper text right and there's also a gem called gem ripper text which will automatically generate text for all your gems or your gem on install so you don't have to manually go to your gem directory and generate the text and this is what allows me to jump to my gem source so vim vim bundler sets the text to include text for gems in your current bundle so vim has this text variable that tracks that basically this all the tag files for your project so vim bundler sets the text to include the text for your the relevant gems that you use in your project so this is super useful if not I wouldn't be able to jump to my gem source straight away vim rbnv yeah sets the text to include the standard library text as well and finally last one I'm using is tag bar so this creates a nice tag bar that allows you to scroll through your project this is super useful for when you have super long files so this is basically tag bar so obviously my I mean this class is not very big but obviously when you're scrolling through very large very complicated source files this can be quite useful yeah so yeah that was my three tips so thank you guys yes any questions can you generate tags for dynamically defined methods dynamically defined methods if I just define method then for example I write methods with almost the same wadi but with a name I use define method I doubted because it's just basically using a parser to read your file so I don't think it's possible to detect stuff on runtime that's general runtime but I mean I think it's pretty good already like yeah compared to reading okay no questions so thank you