Yehuda Katz

For the runtime, there is not much dark magic. Each type that has an `extend T::Sig` has `method_added` hooks registered, which notifies Sorbet runtime whenever a method is defined on the type. When that `method_added` hook is called, Sorbet runtime uses the sig flag that you mention to associate the `sig` with the method definition that follows it. It is, more or less, an implementation of this idea: https://yehudakatz.com/2009/07/11/python-decorators-in-ruby/

Hello, 1. Package managers are very hard! The same problems wrt dependency resolution pop up again and again. Whatever you do, I recommend uhm, copying whatever Yehuda et al did for Ruby, Rust, Yarn, i.e. bundler/cargo/yarn There's lots of prior art out there, and a few days of reading can save you months of terrible effort! Here's one example but there's loads more out there https://yehudakatz.com/2016/10/11/im-excited-to-work-on-yarn-the-new-j… 2. Namely, I don't see any lock files! I didn't look very hard. But get yourself some lockfiles. I also can't stress this enough. 3. Packaging signing really needs to be baked in from the get go, re: https://news.ycombinator.com/item?id=19733085). Good luck!

For what it's worth, I completely agree with the "crappy alias" thing, and wrote a lot about this topic back when I was working on Rails full time (example: http://yehudakatz.com/2009/03/06/alias_method_chain-in-models/). Ruby eventually added `prepend`, which I demonstrated upthread, and is a genuinely generic, in-language solution to the problem you're talking about.

This is a copy-and-paste version of what you said yesterday. https://news.ycombinator.com/item?id=5411929 For what it's worth, the SproutCore 2.0 project became the Ember project (see http://yehudakatz.com/2011/12/12/amber-js-formerly-sproutcore-2-0-is-n… SproutCore 2.0 was a brand-new codebase, which was renamed to Ember.js.

I tend to agree with Yehuda Katz (a Janus co-creator) that training wheels like that which Janus offers are the best way to learn Vim. http://yehudakatz.com/2010/07/29/everyone-who-tried-to-convince-me-to-… I learned Vim the hard way because I was a student at the time, I was required to do so (or Vi at least) and I had the time to invest in it. For people learning Vim on the job, the choice is either use expedient shortcuts or go back to TextMate. Better to start this way and gradually work towards the bare metal.

Yehuda Katz has a nice article on the prototype system that I generally point people to. http://yehudakatz.com/2011/08/12/understanding-prototypes-in-javascrip… And the JavaScript Patterns book is a good read to get an overview of what can be done with just JavaScript. If your application is even remotely complex you'll probably end up using something like backbone or sproutcore which provide constructs for organizing your code anyway.

IMO this is the best overall Vim add-on repo (for Python and Ruby devs alike): https://github.com/carlhuda/janus [1] [1] http://yehudakatz.com/2010/07/29/everyone-who-tried-to-convince-me-to-…

say "this version or greater" That only works if all future versions are guaranteed to be backwards-compatible with the current version. A guarantee that does not exist. See here: http://yehudakatz.com/2010/08/21/using-considered-harmful-or-whats-wro… A version requirement is a statement that "I have tested this code with these versions of the dependencies and verified that it works." Yes, given sufficient time and energy one can also test the code against many older versions of the dependencies, find any bugs, and include explanatory comments, as you suggest. But one can't test against the dependencies as they will exist in the future.

The jQuery project has been working on this this particular plugin for a while now. Based upon what Yehuda wrote up in his original Handlebars.js blog post: http://yehudakatz.com/2010/09/09/announcing-handlebars-js/ He also recommends the official jQuery templating plugin. As is the case with most templating plugins there are minor syntax differences - although it does appear as the two plugins tackle the underlying problem in very similar manners (leading to fast execution time). I've pinged Yehuda so that he can comment here, as well.

Even as a new Vim user I'm constantly wishing all my text editing had it's features. Vimtutor is great, but for a general outlook for someone learning vim this post is spot on: http://yehudakatz.com/2010/07/29/everyone-who-tried-to-convince-me-to-…

Are you thinking of Yehuda Katz who works at EngineYard? http://yehudakatz.com/

Ember is the PostgreSQL of JavaScript frameworks. Similar to the way Postgres has deep roots that trace back to Ingres[1] in the days before SQL was a solidly established standard, Ember traces it roots back to SproutCore[2] in the JS framework pre-historic era of 2010. And the same way PostgreSQL was seen as a second-tier or only "historically significant" open source database, the PostgreSQL team just kept at it, toiling away year after year, steading churning out awesome code and excellent documentation, getting better and better with each release. Like clockwork. In the same way PostgreSQL is now, finally, enjoying more popularity and getting the recognition (long overdue in my opinion) for the awesome platform that it is, I expect that in time more developers will come around to appreciating Ember. The Ember leadership is definitely approaching the project and the processes around it like they intend to be not just relevant but pushing the boundaries for a long time to come. For one example this boundary pushing, you should not miss @tomdale's talk at ReactConf about GlimmerJS (the view layer extracted from EmberJS). It is, in my humble opinion, simultaneously mind-blowing and and inspiring.[3] [1] https://www.postgresql.org/about/history/ [2] http://yehudakatz.com/2011/12/12/amber-js-formerly-sproutcore-2-0-is-n… [3] https://www.youtube.com/watch?v=nXCSloXZ-wc

> There is no progressive enhancement way around this issue, and an opt-in string doesn’t do the job either. In essence, we break backwards compatibility of scripting of the web. This could be not a big issue, if browsers supported ES6, but we’re not quite there yet. This post misses the single most important tool for users (to help them try syntaxes), framework developers (to help them be more productive and consistent), and standards developers (to get feedback): Transpilers. Because much of ES5 is reflective (and ES6 even more so), it makes a great target for the translation of a new syntax into old syntax. This cycle of reflective-api-to-new-syntax is exactly what Yehuda is talking about in his post http://yehudakatz.com/2013/05/21/extend-the-web-forward/. The impact of transpilers on ES module syntax, ES classes, and ES promises as been amazing. You can see the same thing happening with decorators/annotations today- real world use in TypeScript is influencing the discussions of TC39. > The current support table of ECMAScript6 in browsers, parsers and compilers doesn’t look too encouraging. A lot is red and it is unknown in many cases if the makers of the products we rely on to run JavaScript will take the plunge. I disagree in the strongest terms. ES6/E2015 is a huge amount of changes, and browsers have been driving the discussion and implementing items as they have stabilized.

For me, I was always annoyed with how tedious it was to edit things. i.e, The gap between what I think vs what I have to do in the editor to get it done. This constant annoyance was what drove me to spend time and energy into learning it. I believe that if you don't care about it, you won't really benefit out of it. Because the whole point of switching to Vim/Emacs is to minimise the gap between what you think and how you do it. Let me give you an example. You'll be thinking, "I need to change all the arguments to a function." In other editors, you'll press the arrow keys until you get to one end, press backspace key multiple times until you get to the other end. In Vim, I'd do "ci(" which means "change everything inside (" - which is pretty much how I think about what I need to do. A similar but more common example is changing text inside quotes. Again, that'd be 'ci"'. Not everyone feels the annoyance about this and if you don'tt, hats totally fine. Learning something just because its cool is never worth it. Learn it if you really care about it. Also read this post by Yehuda Katz about how he started for some ideas. http://yehudakatz.com/2010/07/29/everyone-who-tried-to-convince-me-to-…

Completely respect where you're coming from, but totally disagree. I made a few abortive switches to Vim that didn't last a week because my productivity was too hampered and the environment too extreme & foreign. To a newcomer like me, Vim's built-in help was less than worthless, since you pretty much need to know the Vim term for what you're looking up to find it. Googling around wasn't much more effective (there's a lot of garbage in the Wikia for Vim that comes up at the top of many searches). In the end, I needed to read these two "gentle" introductions to Vim to even understand what it was all about: http://stevelosh.com/blog/2010/09/coming-home-to-vim/ http://yehudakatz.com/2010/07/29/everyone-who-tried-to-convince-me-to-… …and then I needed a mostly-well-documented distro like Janus (https://github.com/carlhuda/janus) to ensure that my productivity wouldn't take a huge hit those first few weeks. Some folks can probably go all-in cold turkey, but I needed the training wheels.

As someone who worked on a Merb app fulltime for about 4 years (before merb 1.0 through to well after rails 3 released) it's more accurate to say that Rails got rearchitected with some of the good ideas Merb had on the backend. When the plan was originally announced, Yehuda blogged (http://yehudakatz.com/2008/12/23/rails-and-merb-merge/): In particular, we will do Merb releases with deprecation notices and other transitional mechanisms to assist developers in tracking down the changes that will come between Merb 1.x and Rails 3. Expect a number of interim releases that get incrementally closer to Rails 3, and expect parts of Merb (most notably the helpers) to be ported to run on Rails 3 in order to further reduce friction. This very specifically did not happen, and a lot of people are stuck on Merb or had a painful migration. Of note, Rails 3.0's first beta was released Feb 4 2010 (just over a year after the announcement), and 3.0.0 final was August 29. Merb had a 1.1 prerelease Feb 20, and the last version (1.1.3) July 10. Since then Merb has been dead. Again Yehuda: You will not be left in the cold and we’re going to do everything to make sure that your applications don’t get stuck in the past. Now I'm sure as part of the merb community I can take some small part in blame of this, but nobody, not merb developers, not rails developers, not merb users (to the best of my knowledge) wound up putting any serious stock…

Sure, lambdas are not new, but there's still some interesting (maybe not worth calling them novel) ideas in Ruby's blocks: First of all the observation that most method only care about a single block. By having custom syntax for "method that takes a single block" you get a certain simplicity that makes methods look like built-in keywords: loop { puts "Nuts" } It does make multi-block methods look ugly, but frankly, I think they look ugly in any language. Lisp has macros (which has both it's advantages and disadvantages), but I find that Ruby's blocks make the lack of macros more tolerable. Compared to JavaScript/Perl/Python-lambas, Ruby's blocks don't introduce another scope. "self" and "return" still refer to the method's scope (I'm not sure what this type of scope is called; it's not the variable scope I'm talking about here). By introducing another set of keywords that work on the block ("next" and "break") you can easily wrap code in blocks without changing the semantics. See http://yehudakatz.com/2012/01/10/javascript-needs-blocks/ for more information about the difference between blocks and lambdas in object-oriented languages.

As someone that has been writing production Rails and Sinatra apps for years, I have to recommend against using Padrino. Rails scales up and down pretty well, and I don't really see a need for Sinatra in anything but very small or single-purpose apps. You can even write a Sinatra clone in very little code on top of Rails: http://yehudakatz.com/2009/08/26/how-to-build-sinatra-on-rails-3/ If you already know Rails, there is very little reason to build a substantial app in anything "smaller". The reality is that for any moderately-sized app, you will end up using many of the parts of Rails that you think are unnecessary in the beginning. Especially as your app grows. I tried using Padrino for an app a year ago, and while the framework has probably matured since then, I moved back to Rails fairly quickly due do a lack of polish/documentation/community/benefit other than being different. There is a common tendency to find a part of a framework that doesn't work exactly the way you want, and in turn throw the entire framework out and seek out or write something new. I still prefer the way Merb and Sinatra handle responses, where the controller action return value is the response sent to the client. But the benefits that Rails provides so outweigh many of these kind of preferences that it's usually best to just embrace the way the framework works and move on to actually building an app that does something. It's also short sighted to discount how valuable the wealth of existing…

> Ruby's metaprogramming facilities are dead simple compared to Python's I actually have the opposite experience, Ruby's eigenclasses and the self way to handle them to create class methods feels convoluted and shoehorning whereas __metaclass__ and the way you inherit of Class feels straightforward to me. The same goes for modules extending/including behaviors versus sane multiple inheritance combined with metaclasses and the way you manipulate methods and functions just assigning them as attributes, without any need for three handfuls of helper methods. Ruby's approach of development is so pervasive that I (and not only me) always have to check if I won't be tripping on someone else's wires. When I tell that, the Ruby crowd shouts at me that Ruby monkey-patching is safe! So let's make it safer[1]! It honestly feels like needless complexity, over-engineering, or jumping through more hoops. I know both approaches quite well but I can't help but think that the Python approach just fits in, like a self-solving Tetris, whereas Ruby feels like I constantly need to solve puzzles. Granted it's fun when you learn the language, drawing a picture of where classes, instances and eigenclasses of each fit, but when you want to be productive you just want it to flow, not solve another damn puzzle of how I can do this smartly so that things don't end up making galaxies collide. PS: don't get me wrong, I actually love both languages, but while it's love-love with Python, it's actually…

I really like this feature (which actually comes from Smalltalk's doesNotUnderstand:). It is actually supported on firefox[1][2][3] as __noSuchMethod__, but it is non standard, and should not be relied when writing cross platform js. But then I guess the thread starts getting a bit off track, and I apologize. The point is: Supporting other languages is good for the framework, and for the community GWT took the position: Java source only. Cappuccino can take the same position: Objective-j only. It is fine. It is also limiting. I am always happier when great frameworks support multiple languages, when it opens the doors for more people, instead of shutting down to a smaller community. It helps create greater value to more people, which I'm always for. It does have its costs. In the end, it is a trade-off which the creators and the community have to make. PS: An example of a framework that does this (written ina more powerful language, supporting a less powerful one) is Akka[4]. It is written in Scala, but its Java interface, while more cumbersome, is so good that I could create a JRuby interface[5] that is even more expressive (thanks to method_missing) than the original one in Scala. [1] https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/O… [2] http://stackoverflow.com/questions/3811408/node-js-overloading-functio… [3] http://yehudakatz.com/2008/08/18/method_missing-in-javascript/ [4] http://akka.io/ [5]…

> I wrote a book on Merb and was an active contributor. It might be a situation where you see it differently because you were involved or benefiting from the way things unfolded > That said, the Rails vs Merb era was mostly good natured competition [...] wouldn't describe any of it as toxic Competition can be healthy, Rails vs Merb was anything but. Quotes from Yehuda himself: ••• "I was just so blinded by tribalism that I never even bothered to check how fundamental the disagreements really were." ••• "waging an all-out war against Ruby on Rails from inside of a company that makes its money selling Ruby on Rails deployment is a pretty bad life strategy" ••• "It's so easy for our brains to turn disagreements about priorities into value conflicts. It takes a lot of effort to see past that mistake." https://yehudakatz.com/2020/02/19/together-the-merb-story/

> Ruby not having first-class functions This is simply false. Ruby has first-class functions. Not only that, it has blocks, which few other languages have. Ruby optimizes for the common use-case of a method that takes a single callback/piece of code, and I miss it in most other languages, including Python. In Python, the "with" statement is super special. But in Ruby, it's just a method that takes a block. And any method can take a block, not just one per class. https://yehudakatz.com/2010/02/07/the-building-blocks-of-ruby/

Ruby doesn't block other waiting threads on IO https://yehudakatz.com/2010/08/14/threads-in-ruby-enough-already/

Maybe Ember.js - https://emberjs.com Yehuda Katz is Core Team Member of Ruby on Rails and Co-Creator of Ember.js https://yehudakatz.com/projects/

I'm in a similar position. I do use vim but only for the most basic of editing tasks. I certainly haven't made the switch - but I read this just the other day and it's at least addressing the issue that we have: http://yehudakatz.com/2010/07/29/everyone-who-tried-to-convince-me-to-…

http://yehudakatz.com/2016/10/11/im-excited-to-work-on-yarn-the-new-js… for those who where curious.

You forgot the link. :) http://yehudakatz.com/2016/10/11/im-excited-to-work-on-yarn-the-new-js…

See also: · http://yehudakatz.com/2016/10/11/im-excited-to-work-on-yarn-the-new-js… · https://yarnpkg.com/

Which is sort of ironic, given that Ember.js was originally called Sproutcore 2.0 [1]...But I digress. Props to Tom, Yehuda, and everyone else. I've been dithering over whether to get up to speed on Ember or React, but I feel like the 'Batteries Included' approach that Ember provides and the very aggressive approach to cruft removal is what's right for me. [1] http://yehudakatz.com/2011/12/12/amber-js-formerly-sproutcore-2-0-is-n…

Yehuda Katz argues that it does not: http://yehudakatz.com/2012/01/10/javascript-needs-blocks/