Presentations

This is a list of links I find intriguing, and would like to revisit from time to time.

§General

• Ramen The broth, the noodle and the toppings.

• 古巨蜥好几吨重，但在我们智人祖先面前也是枉然 | 袁硕 一席第449位讲者 Anthropology is interesting as well, LOL.

• Reconstruction 1 Reconstruction 2 It’s really amazing work. There’s no absolute garbage; it’s just misplaced treasure. I hope I could live in such a place someday.

§CS related

• Tree-sitter - a new parsing system for programming tools It seems that it can reduce the complexity of building a parser.

• The Art of Code I am not even qualified as a hello-world developer…

• Performance Matters The sqlite example, optimizing functions that accounts for 0.15% according to perf could bring 25% improvement, is counterintuitive and mind-blowing.

• Parser Parser Combinators for Program Transformation Looks neat enough to do some simple code transformation in large scale.

• git-extras introduction A new world if you use git aliases.

• XSS on Google Search - Sanitizing HTML in The Client? HTML is too complex to be parsed properly…

• Alan Kay - Programming and Scaling Didn’t get much concrete info from it, but maybe inspiring philosophically.

• The future of Visual Studio I was most amazed by the voice-oriented programming and windows subsystem for Linux parts.

• Partial Derivatives of Regular Expressions Surprisingly, I find this talk fairly easy to follow. Since the new approach promises simpler logic and better performance (in certain cases), I wonder if there’s major re-write for current RE lib. (I didn’t find the repo for this work.)

• HotSpot Internals_ Signals, Safepoints and NullPointers - Volker Simonis It’s cool to see how sophisticated JVM internal is.

• Mike Bostock - Keynote - CSVConf 2017 The visualization is super cool, and it kind of reminds me of ipython (the python notebook). However, by utilizing JS, and custom html input, it seems this approach is even more powerful. Either way, I am not touching visualization.

• William Byrd on “The Most Beautiful Program Ever Written” In the line of SICP, but I think the style used in r2 is cleaner. The latter part, where he shows how to synthesis program via exploiting equality is mind blowing.

• Python, Linkers, and Virtual Memory It’s titled Python, but the points are much more general. Really good and clear explanation on this topic.

• Object-Oriented Drawing It’s rather cool; however, I cannot paint or draw…

• Debugging Code that Crashes the BEAM - Richard Kallos It’s interesting to see that we have all those tools, but still it feels quite awkward. I wonder if we can have reasonable C-like speed in Erlang, then we don’t need to call C from Erlang any more.

• Systems that Run Forever Self-heal and Scale Super hard problems are all in distributed systems. I am lucky that I don’t work with them. LOL.

• Zero to GraphQL in 30 Minutes – Steven Luscher It’s quite impressive to see how easy it is to get started using GraphQL. Seems a sensible idea, IMO.

• Kernel documentation: what we have and where it’s going It’s good to see that someone is working on improving the documentation. Linux repo is a gold mine, but the barrier to enter is just too hight; I am still lingering outside…

• JavaScript is Awe-ful All languages have quirks. Sigh…

• Garrett Smith - Why The Cool Kids Don’t Use Erlang The best part about Erlang, imo, is the property-base testing tool, proper. The syntax is still awkward to get used to.

• Timothy Gowers: The Importance of Mathematics (Full Lecture) Try to appreciate the beauty of mathematics, but I am too dumb to comprehend it. Sigh…

• Meteor.js with Matt Debergalis The idea of caching complete or partial DB on the client side seems quite neat. I have never done any collaborating web apps, so really don’t know much about this topic, but I will give it a try if I encounter such opportunity.

• Live Development with Brackets Editing loaded web page inside a browser seems so natural that I can not believe that’s not how it’s done all the time. Anyway, I have said goodbye to GUI programming…

• “Runtime scheduling: theory and reality” by Eben Freeman A close look at OS and userspace scheduling, specially, Go and Erlang. The paper mentioned in the end of the talk presents an overview of the Linux scheduler, which is an excellent and accessible read.

• MuniHac 2016: Beautiful folds are practical, too The standard derivation example is rather convincing. The idea of composing folds and apply them in the end reminds me of parser combinator. Considering that FP promotes composing small functions to achieve large functionality, this should not be too surprising, but still it’s pretty neat.

• An Introduction to Linux IPC Facilities Basics on POSIX IPC.

• Why Google Stores Billions of Lines of Code in a Single Repository It’s impressive that they pulled it off with single repo. On the other hand, maybe only large corporations could afford investing huge resource on infrastructure construction.

• Tor: Hidden Services and Deanonymisation It’s interesting to have a peek into how tor, the most widely used anonymous service, works.

• How to Doodal I thought I could draw something fancy with this tool, but I think I was toooooo naive after trying http://dood.al/ for a bit.

• SpiderMonkey Parser API: A Standard For Structured JS Representations Amazing JS ecosystem. Being a language notorious for its quirks, is JS really a good choice as the target language or platform?

• RailsConf 09: Chris Wanstrath, “How to become a famous Rails Developer, Ruby Rockstar or Code Ninja” Applicable to CS in general, not only Rails. (The transcript available here.)

• Build 2016 : What’s New in TypeScript The interoperation between JS and TS is amazing. It’s very likely that TS will be adopted for enterprise JS development.

• Spotify Engineering Culture After watching this, I really want to work in that company.

• 清华 2016 网络安全科普日 It’s not too technical; I could follow the presentation mostly.

• AxiDraw personal writing and drawing machine writes for you It’s so pleasing to see how it draws everything.

• Anders Hejlsberg on Modern Compiler Construction The front end part of a compiler should be extracted, and renamed to language engine or something like for it could answer queries on the code base. As for the on-the-fly AST construction + typechecking, I didn’t fully catch what he explained. My personal idea would be to identify the block boundaries (module, class, or method), so that info from other unmodified blocks could be reused. Maybe it’s the same (or very similar) to what he explained on reusing AST nodes.

• Andy Keep - Writing a Nanopass Compiler The nanopass framework is quite neat; maybe it can be done in Haskell with less quirky syntax. In fact, with map fusion, it should be possible to keep the neatness of having nanopass without the high overhead.

• The S.O.L.I.D. Principles of OO and Agile Design - by Uncle Bob Martin It’s new to me that polymorphism (programming against interface) is so ubiquitous and powerful. The VS plugin example is very inspiring, that it’s possible to add new features without modifying the existing code. Function pointers are used behind the scene to implement polymorphism. As it’s pointed out that C has polymorphism (e.g. getchar), but it’s comparatively more verbose to use.

• A History of Haskell: being lazy with class You might not write much Haskell code after learning it, but learning it does have formative impact on how you write code in whatever language you prefer.

• Best Berlin Pitch ever!!! [BETTER QUALITY] Visited not long before watching this presentation. Possibly feel more touched because of my stay, but still, quite a good one.

• A Tour of the Acme Editor It’s more like an OS than a editor. Navigating using local URI is quite cool, which reminded me that developers using IDE to poke around unfamiliar code base before switching their own editor for development.

• The Road to Running Haskell at Facebook Scale - Jon Coens Due its pureness, it’s awkward to integrate Haskell with other language, I feel. However, according to what he presented, Haskell is pretty good at DSL. Haxl seems to be dealing with the same (or similar) problems Relations in RoR and LINQ in Dot Net have dealt with.

• Pony - A new, race-free, safe & fast actor programming language It’s great to see how the runtime works from a high level after being involved with it for a long time.

• New Bionics Let Us Run, Climb and Dance | Hugh Herr | TED Talks It’s a miracle to see how technology could change one’s life so profoundly. It’s actually not that far-fetched do change the world.

• YOW! 2015 - Reid Draper - Production Haskell It’s actually not bad to write pure Haskell in backend.

• A Deep Specification for Dropbox - Benjamin Pierce Played with Property-based Testing in Erlang in one functional programming course. The overall experience is pleasant.

• Netflix JavaScript Talks - Debugging Node.js in Production Feels like CSI; so cool.

• RubyConf 2015 - Everything You Know About the GIL is Wrong by Jerry D’Antonio It’s actually not too much different from how Node work: IO operations don’t block the whole system, but pure computation is single-threaded.

• RubyConf 2015 - How to Stop Hating your Test Suite by Justin Searls I think there’s some magic/principle in writing tests. It’s a bit hard for me to grasp them, and writing tests in indeed painful, and my Rspec tests are so slowwww…

• RubyConf 2015 - String Theory and Time Travel: the humble text editor by Colin Fulton I do have some kind of special feeling towards editors. Wish I can find a better one.

• Frege, a Haskell for the JVM by Dierk König Haskell on JVM.

• Haskell Stack Mega-Tutorial Finally, a decent package manager for building Haskell projects.

• How to Think about Parallel Programming: Not! Doesn’t feel much has changed from four years ago. (Written in 2015.) We will see in another four years.

• How We Teach Computers to Understand Pictures | Fei Fei Li | TED Talks It’s amazing to see what CV can accomplish right now.

• Ron Pressler - Pull Push: Please stop polluting our imperative languages with pure concepts-Curry On I do feel lacking of call-stack info a bit inconvenient while debugging crashes of my Haskell program.

• Computing a theory of all knowledge Looking forward to the ultimate truth.

• C++ Seasoning C++ is used in this talk, but his first two points can be applied in other languages. The final point makes me feel that no-pointer and no-GC is rather bizarre combination.

• FP Graph Algorithms I know that graph is not a common data structure in FP, but it’s not very clear to me why. This talk pinpoints the non-inductiveness of graph, which makes it not a good candidate for algebraic data type.

• Program Synthesis from Refinement Types What it could do currently is fairly limited, but it’s quite promising.

• David Christiansen - Coding for Types: The Universe Patern in Idris - Curry On Since we deals with values in our program, there’s no reason why we couldn’t do the same with types. Kinds in Haskell is one approach for this, but it’s quite primitive compared with what we can do with values. There’s clear boundary between values and types in Haskell, but Idris treat them in the same way. Not sure if it’s good; consistency or complexity.

• Sumit Gulwani - Data Manipulation using Programming By Examples and Natural Language - Curry On It would be great if this FlashProg is available as a standalone application in some way. Still, quite promising, Programming By Examples (PBE).

• Jurriaan Hage - Making Embedded Domain Specific Languages a Practical Reality It’s ingenious to customize the error messages outside of the compiler. The syntax proposed in the presentation is a bit unwieldy; I am wondering if we could uses something similar to construct the type checker itself.

• 10 Things I Learned from the jQuery Source A little peek into jQuery black box. It’s great to have an expert to walk you through high quality code. JS is a very flexible language.

• LMAX - How to Do 100K TPS at Less than 1ms Latency It’s just simple idea, not sure why it made such huge difference. Hope I could know more about it.

• From Haskell to Hardware Type Driven development in Haskell. Haskell does provide a unique perspective on solving problems; quite insightful.

• Haskell at Wagon It’s good to see how Haskell is used in industry. electron, competitor of NW.js, and conduit seems quite handy libraries.

• LXJS 2012 - James Halliday - Harnessing The Awesome Power Of Streams In the current Big Data era, stream processing seems the right way to go, and stream support in Node.js feels so natural.

• One Hacker Way - Erik Meijer It’s good to see something radical.

• CODE GENIUS - Rise of the Transpilers by Jeremy Ashkenas The lexer and rewritter are quite hairy; it’s not very obvious what the code at first glance. Maybe we can do better. Thanks to their hard work, CoffeeScript’s syntax is the most flexible, IMO.

• Refactoring Ruby with Monads Some concrete Ruby examples on using Monad.

• Machine Learning for Programming It’s the future. Come to think about it, programs are built on specification by developers, and it doesn’t seem unreasonable that ML could mimic the process of constructing functional systems based on specification as well. (I knew CS as a profession is doomed.)

• If Only I Knew This Shit in College Some advice from Pro.

• How to Debug Anything One could learn some tricks on debugging, and debugging stories are always exciting.

• Zach Holman: move fast and break nothing DevOps stuff.

• SpiderMonkey Parser API: A Standard For Structured JS Representations A whole ecosystem around JavaScript.

• Language Panel Six language authors in one panel.

• What the heck is the event loop anyway Very good visualization of how call stack works; it’s specific to JS, but the general idea is applicable.

• Ungit introduction Very intuitive intro to git. I guess it would have been much easier to learn this master pointer manipulation, such as reset, rebase, etc, if I saw it when I learned it.

• JavaScript Tools at Scale Using Type Information Pretty clever usage of type information from one dynamic language. The Conformance tool makes more sense to be included in the linter to me. As he mentioned, if the manually add type info (introduced in the comment) could be replaced by the type inference, this could be more practical and convenience.

• Guido van Rossum on the History of Python Some anecdotes about Python. One may learn something on how one sort of successful language is designed and evolved.

• Seeing Spaces Shouldn’t constrain ourselves into the small monitor of a computer. Let’s have touchable screen everywhere.

• Paintcode Creating GUI using text (code) feels powerless, and this is much better. Everyone who’s keen on learning iOS development should watch this.

• All About Polymer at SFHTML5 Very exciting. I do believe HTML/CCS/JS is too primitive to do web development directly. Mobile development is no exception.

• Erlang Factory 2014 – Keynote Catalyse Change The presenters believe the situation could be relieved by having accessible good tutorials. However, the biggest issue, imo, is the syntax. Not sure how Elixir will go.

• Realtime Web Apps with AngularJS and Firebase Distributed, real time app constructed in minutes. I am definitely not adept in app development.

• Live coding a mobile graphics app with Gideros SDK and ZeroBrane Studio Quite cool, but game dev is still so verbose…

• Ruby Conf 2013 - REPL driven development with Pry by Conrad Irwin It would reach more popularity if one GUI without some shortcut is provided. This time, I believe GUI is more productive.

• Inventing on Principle Totally blows my mind. Open the window to the new world.