[Video 419] Jeremy Clark: Learn the Lingo — Design Patterns

Do you use design patterns in your code? Probably — but that doesn’t matter, because the term “design patterns” probably sets you on edge so much that you haven’t stopped to consider whether you’re using them, and what advantages they might give you. It turns out that design patterns make it easy for you to communicate with other developers, to reason about the way in which you’re architecting your code, and to take advantage of the thought that many others have put into certain ways of developing software. In this talk, Jeremy Clark describes the reasons for learning design patterns, and then describes several of the most common ones that you’re likely using already, even without knowing it.

Time: 1:04

Additional materials: http://www.jeremybytes.com/Demos.aspx#LLDP

[Video 418] Dave Thomas: Agile is Dead

For years, we have been hearing that “agile development” will save the software industry. And now, you can’t get away from it; every company claims to be agile, with Post-It notes, stand-ups, and tons of training for Scrum masters and the like. But the term “agile” has become a meaningless buzzword, used by companies to describe whatever management wants to do, with a few notes stuck on walls. So says Dave Thomas, one of the original authors of the Agile Manifesto. If that’s the case, then what’s next, and how should we develop software? In this talk, Dave describes what he means, and how developers should think about projects, communication, and scheduling over the next few decades.

[Video 417] Rob Pike: Go Proverbs

The Go language has become extremely popular in the last few years. This highly parallel, open-source language sponsored by Google is a systems language, meaning that it’s meant to be used for high-performance operations where C and C++ currently rule. As Go has matured, developers have found that certain practices make it easier to write and maintain their programs. In this talk, Rob Pike proposes a number of “Go Proverbs,” which should help to instruct, direct, and influence developers as they go about designing and implementing their software in Go.

[Video 416] Kate Gregory: Stop Teaching C

If you’re teaching people how to program in C++, then the odds are good that you’re doing so by starting with C, and then building on top of that. This, argues Kate Gregory, makes for lots of problems. It means that you only get to the interesting parts of C++ long after the first day of the class. It reflects the history and evolution of the language, rather than the way in which people use (and should use) it today. And it means that you teach your students to deal with things in a way that is good for C, but bad for C++. If you teach programming, in any language, then this talk offers a fascinating perspective on what and how to do so.

[Video 415] Gaurav Seth: Inside Chakra

Chakra is Microsoft‘s JavaScript engine, and as of this month (January 2016), its core is now released under an open-source license. But what exactly does Chakra bring to the table? And how is it different from other JavaScript engines? In this talk, Gaurav Seth provides us a full picture of Chakra — from its origins to its current state of affairs, including licensing, technical capabilities, speed, debugging support, architecture, and future plans. If you’re interested in JavaScript — and let’s be honest, if you have a Web browser, then you should be interested — and would like to keep up on the latest in the competition among open-source JavaScript engines, then this talk should be of great interest to you.

[Video 414] Lisa Maurer: Learner at the Center — LX Design and Research

Here’s something that you’ve probably heard before: If we introduce technology into classrooms, then students will learn more, better, and more effectively. But the reality is different; just throwing technology at the problem doesn’t help. Which raises the question: What kinds of designs do make for real educational differences? In which classes, and in which ways, can we really use technology to improve learning? In this talk, Lisa Maurer describes work that she and Pearson are doing to research and improve UI/UX design to improve learning outcomes.

[Video 413] Chandu Tennety: A Bird’s Eye View of ClojureScript

ClojureScript is getting lots of attention as an elegant way to write client-side programs. But what sorts of things can you really do? What sorts of applications are made possible by ClojureScript? In this talk, Chandu Tennety describes an application he wrote to analyze and visualize bird migration. He describes how they read the data, interfaced with other libraries (e.g., D3), and even stored the data using Datomic.

Time: 58m

[Video 412] Nik Everett: Wings Stay On, or Replacing On Site Search at Wikipedia

Wikipedia is both big and famous. Thus, any changes made to Wikipedia are going to affect many people. Moreover, something such as search is used frequently, by people around the world, and in many different languages. So, when the decision was made to change how Wikipedia implements its search system, this meant a lot of thought, planning, testing, and then deploying. In this talk, Nik Everett describes this process, and how Wikipedia switched over to using ElasticSearch without too many problems.

Slides: http://gotocon.com/dl/goto-amsterdam-2015/slides/NikEverett_WingsStayOnOrReplacingOnSiteSearchAtWikipedia.pdf

Time: 45m


[Video 411] Alex Burkhart: In Rust We Trust

Rust is a new programming language, aimed at making systems programming reliable, even when dealing with concurrency. Rust, whose development is sponsored by the Mozilla foundation, is gaining many fans who have not previously worked with static, compiled languages. What is it like to work with Rust? And what does it offer that other languages can’t or don’t? In this talk, Alex Burkhart tries to answer these questions, including why the Rust community continues to grow, providing support to newcomers.

[Video 410] David Greenberg: Dynamic vs Static — Having a Discussion without Sounding Like a Lunatic

Which is better, dynamic or static typing?  For many years, this question has divided programmers, often bitterly. What are the advantages (and disadvantages) of the different approaches of typing, and how can we advocate for an approach without being blind to the trade-offs associated with that approach? In this talk, David Greenberg surveys a number of languages, approaches, and trade-offs,  and how we can think about static vs. dynamic typing without getting into crazy arguments. Moreover, he describes how static typing can be seen as a benefit, rather than a straitjacket, as many dynamic-language aficionados might believe.