HN Theater @HNTheaterMonth

Well, .NET's garbage collector certainly springs to mind. Not exactly in a good way. You know you have something special on your hands when GitHub refuses to show you a highlighted version of a hand written C++ file (https://github.com/dotnet/runtime/blob/98984ccad55362a66b7fd...).

Other than that, I remember my mind was blown a few times while watching Jim Weirich's presentation on functional programming all those years ago (https://www.youtube.com/watch?v=FITJMJjASUs).

⬐ nso95

The GC code does look like a collection of garbage

⬐ roflyear

Many MS libraries are just total garbage, it's crazy. Reading the source and looking at the bugs (features just flat out not working, must have never been tested) is mind opening.

⬐ klabb3

Sometimes the garbage takes out itself.

⬐ bob1029

The GC is the only thing I strongly dislike about the .NET ecosystem. I would really like some option to turn it off altogether (like what Java offers).

I've got several short-lived applications that are extremely latency sensitive and would work flawlessly this way.

⬐ jcparkyn

Out of curiosity, do TryStartNoGCRegion and/or GCLatencyMode.SustainedLowLatency not meet your needs?

⬐ bob1029

I've not had luck with either. The application may allocate more than a single GC segment worth, so the best workaround is to detect an imminent GC and migrate the workload. Unfortunately, migration would incur even more severe penalties than a typical gen2 collection.

⬐ bpye

You say hand written but actually, it wasn’t exactly. The original version was apparently in LISP and then translated to C++ [0].

[0] - https://learn.microsoft.com/en-us/archive/blogs/patrick_duss...

A good video that made it click for me is the following, which derives the ycombinator from 1st principles:

https://m.youtube.com/watch?v=FITJMJjASUs

On the same topic, Jim Weirich's 2012 talk "Y Not - Adventures in Functional Programming" on lambda calculus and the (little 'c') Y combinator is fantastic.

https://www.youtube.com/watch?v=FITJMJjASUs

⬐ inopinatus

    Gather 'round while I sing you of Wernher von Braun  
    A man whose allegiance
    Is ruled by expedience
    Call him a Nazi, he won't even frown
    "Nazi, Schmazi!" says Wernher von Braun

    Don't say that he's hypocritical
    Say rather that he's apolitical
    "Once the rockets are up, who cares where they come down?
    That's not my department!" says Wernher von Braun

    Some have harsh words for this man of renown
    But some think our attitude
    Should be one of gratitude
    Like the widows and cripples in old London town
    Who owe their large pensions to Wernher von Braun

    You too may be a big hero
    Once you've learned to count backwards to zero
    "In German, und Englisch, I know how to count down
    Und I'm learning Chinese" says Wernher von Braun

-- Tom Lehrer, That Was The Year That Was, Reprise Records 1965.

Here is a good one that come to mind:

1. This one is alive demo where the speaker derives the Y Combinator from first principles. A really interesting exposition of functional programming at its finest. Link: https://www.youtube.com/watch?v=FITJMJjASUs

⬐ chmaynard

OMG! This is why I love HN. I downloaded Jim Weirich's presentation so I can watch it offline a few hundred times.

My favorite video of all time: https://www.youtube.com/watch?v=FITJMJjASUs

Jim Weirich's 2012 Ruby Conf talk is also a great introduction to the Y Combinator and Lambda Calculus.

https://www.youtube.com/watch?v=FITJMJjASUs

This video (similar lecture, different audience) has the slides alongside the talk: https://www.youtube.com/watch?v=FITJMJjASUs

Still one of the best programming talks I've ever seen.

Finally made an account to post in this thread.

I'm rather early in my career doing mostly Ruby, Python and JavaScript things. As you might expect, I consume mainly Ruby, Python and JavaScript related talks.

The first two talks that really blew my mind are:

- K Lars Lohn's PyCon Keynote from 2016: https://www.youtube.com/watch?v=bSfe5M_zG2s

- Jim Weirich's (RIP) "Y Not" talk from RubyConf 2012: https://www.youtube.com/watch?v=FITJMJjASUs

There are many other presenters who I have a good opinion of:

- Raymond Hettinger: his presentation/teaching style is something I'd like to model my own after, also he gave the first talk on writing proper threaded/concurrent python that I was able to understand and make use of.

- Brandon Rhoades: another speaker with a presentation style that I've found easy to follow, also he takes a little shot at the dd utility about 18 minutes into https://www.youtube.com/watch?v=z9Hmys8ojno)

- Sandi Metz: I started out in Python land and moved to Ruby land, where I was introduced to Sandi's talks. She doesn't talk about incredibly complex topics, but she's got insight into some really basic things that's helpful to new people who can't see the forest through the trees.

- Robert Martin: I gather that his OO principles are not universally revered, but I find his talks useful.

- Gary Bernhardt: his talks are interesting and entertaining in ways that most are not

The list goes on, but I can't think of them all right now.

My favorite talk of all time is “Y Not - Adventures in Functional Programming by Jim Weirich”.

https://m.youtube.com/watch?v=FITJMJjASUs

For those (like me) that prefer learning through talks and demonstrations, Jim Wierich gave an incredible talk on the Y Combinator at RubyConf 2012.

Video: https://www.youtube.com/watch?v=FITJMJjASUs

Code: https://github.com/jimweirich/presentation_ynot

Y Not - Adventures in Functional Programming by Jim Weirich https://www.youtube.com/watch?v=FITJMJjASUs

The Coming Civil War over General Purpose Computing by Cory Doctorow http://boingboing.net/2012/08/23/civilwar.html

Cybersecurity as Realpolitik by Dan Geer https://www.youtube.com/watch?v=nT-TGvYOBpI http://geer.tinho.net/geer.blackhat.6viii14.txt

⬐ HCIdivision17

I'll second "Y Not" by Jim Weirich. It's just such a charming talk. My programming teacher in high school was like that, and I think it's such an excellent way to teach. From the careful way he meanders to the solution to the fact it was a live coding session really grounds the explanation of how the Y combinator works.

⬐ qwertyuiop924

To Dissect a Mockingbird is even better, though...

here is a great live coding demo that explains the y combinator from first principles

https://youtu.be/FITJMJjASUs?t=936

Jim Weirich's "Y Not - Adventures in Functional Programming"[1] is perhaps the most entertaining and interesting technical talk I've ever seen. It would absolutely not be as cool or as fun without the live coding. Additionally, the incremental process by which he arrives at the conclusion makes the topic much more approachable.

1. https://www.youtube.com/watch?v=FITJMJjASUs

⬐ brucehubbard

I came here just to say the same thing. I loved Jim's presentation and have watched it several times.

Reading this, I was struck by how it reminded me of a talk that slowly warped and wrapped a statement to build up the Y-combinator. The process takes a self-referential function and slowly works the self out of it.

Honestly, I'm not at all sure turning a function anonymous is actually similar to making a sentence passive, but maybe re-watching that video now I'll have that je ne sais quoi that'll let me actually grok the process.

[0] https://m.youtube.com/watch?v=FITJMJjASUs

⬐ agumonkey

I think that 'je ne sais quoi' was just Jim Weirich, he was very very good at teaching.

I mean, sure, it's going to be turtles the whole way down if you're looking to define the universe without resorting to physical quantities (that is, dimensioned units). We don't have anything like a Grand Unified Theory yet, wherein we define Physics by means of some elemental mathematics (in the form that we can bootstrap computation from lambda calculus via things like the Y Combinator [0]). Besides, we occasionally give dimensional names to dimensionless quantities (my favorite being the engineering unit the inverse radian) [1]. It's a useful abstraction, and it seems confusing to complain about it.

So we resort to what we know, which is what we see. We can't see more than the surrounding universe, but we can try extrapolating from what seems to work. Attempting to stifle that inquiry seems a bit... I dunno, pointlessly antagonistic.

This article shows science in action, doing what it does best: taking observations and reconciling them with other observations via theory, and then fixing theory to match. It seems our universe follows certain equations which are themselves dimensionful, so I'm not sure why we wouldn't attempt to benchmark the universe against itself - we don't have much else to use. Even dimensionless numbers are only marginally useful, like alpha; it may "exist" and manifest as our universe, but it's not especially predictive.

[0] https://www.youtube.com/watch?v=FITJMJjASUs (one of my favorite videos - I still don't grok it, but I'm getting closer!)

[1] http://arxiv.org/pdf/1409.2794.pdf

One of my favorite programming videos: Jim Weirich on the Y Combinator https://www.youtube.com/watch?v=FITJMJjASUs

⬐ prawks

Great video, I was hoping it would be linked here. Jim's is not only an informative talk but an inspirational ability to teach.

⬐ jparishy

If anyone hasn't seen this I highly recommend it, if not just because Weirich was a great guy and was very entertaining. RIP.

⬐ vhost-

Thanks for this. I just learned a lot!

⬐ bsaul

Thanks for letting me discover the work of that man. Its approach to learning about something by actually doing it really shines in the video you linked.

⬐ jiggy2011

I think he passed away recently :(

⬐ vqc

He did. And that's how I learned about him and video.

Since it is not readme based, I suggest including Y-Not[1] - an excellent talk about functional programming and lambda calculus

[1]: https://www.youtube.com/watch?v=FITJMJjASUs

⬐ phatak-dev

You can contribute by forking here https://github.com/phatak-dev/techtalks.

Confreaks.com seems to be having some troubles, I'm guessing this is the same talk:

Ruby Conf 12 - Y Not- Adventures in Functional Programming by Jim Weirich (uploaded by Confreaks):

https://www.youtube.com/watch?v=FITJMJjASUs

http://www.youtube.com/watch?v=FITJMJjASUs

This talk is a must-see, really shows off Jim Weirich's craft and overall ability to be a great pedagogue.

⬐ davelesser

I experienced this talk in person and, for me, it was the highlight of the conference. "Highly technical. Extremely Pointless. Worst Ruby Code Ever."...and 100% amazing (though the American Sign Language interpreter, for whom signing this talk appeared to be a Herculean effort, might have a different opinion).

Great talk. Greater man.

⬐ Derbasti

Yes it is! This talk is absolutely awesome!

+1 on the lambda calculus stuff. Here's a related talk about deriving the Y combinator in Ruby by Jim Weirich:

http://www.youtube.com/watch?v=FITJMJjASUs

(skip to about 28:00 if you're impatient)

There are additional versions of this same presentation circulating with the code in Javascript and (I believe) Clojure. Full disclosure: Jim is a co-worker of mine.

⬐ actsasbuffoon

I've seen a JavaScript version of that talk. My respect for Jim is one of the reasons I switched to Emacs.

If you are curious about the topic, I strongly recommend watching these videos:

Y Not- Adventures in Functional Programming by Jim Weirich http://www.youtube.com/watch?v=FITJMJjASUs

Programming with Nothing by Tom Stuart http://www.youtube.com/watch?v=VUhlNx_-wYk

Jim Weirich derives the Y combinator in pure Ruby here:

http://vimeo.com/45140590

EDIT: Correct video http://www.youtube.com/watch?v=FITJMJjASUs

It is some of the ugliest ruby code I have ever seen, but it was something amazing to watch happen live.

⬐ baddox

Is the Ruby hiding in that video? I briefly skimmed it and all I saw was JavaScript.

⬐ tesmar2

You are correct, I edited the comment with the right video.

⬐ eggsby

Nice, I enjoyed Jim's talk where he derived the combinator using clojure[1]. In it he referenced another talk that he cites as an influence, "Programming With Nothing"[2] by Tom Stuart where he writes fizzbuzz in ruby using only lambda application.

Finding the SKI calculus was a similar revelation to me, that such simple combinators could represent any lambda term is such a huge idea!

1: http://www.infoq.com/presentations/Y-Combinator

2: http://rubymanor.org/3/videos/programming_with_nothing/

⬐ gwright

A fascinating example of higher-order function refactoring in Ruby leading to the derivation of the Y Combinator.

I was really impressed at how smoothly the live coding portion of the presentation proceeded despite the complexity of the material being presented.