Thinking Above the Code
Architects draw detailed blueprints before a brick is laid or a nail is hammered. Programmers and software engineers seldom do. A blueprint for software is called a specification. The need for extremely rigorous specifications before coding complex or critical systems should be obvious—especially for concurrent and distributed systems. This talk explains why some sort of specification should be written for any software. http://www.microsoftfacultysummit.com
An Overview of Probabilistic Programming
Probabilistic inference is a widely-used, rigorous approach for processing ambiguous information based on models that are uncertain or incomplete. However, models and inference algorithms can be difficult to specify and implement, let alone design, validate, or optimize. Additionally, inference often appears to be intractable. Probabilistic programming is an emerging field that aims to address these challenges by formalizing modeling and inference using key ideas from probability theory, programming languages, and Turing-universal computation. This talk will illustrate the common underlying principles of probabilistic programming using three research platforms: BayesDB, a Bayesian database that enables users to directly query the probable implications of data tables without training in statistics. It provides BQL, an SQL-like language for Bayesian data analysis, and MML, a minimal language for building generative population models by combining automatic model-building techniques with qualitative constraints and custom statistical code. BayesDB has been applied to problems such as cleaning and exploring a public database of Earth satellites and assessing the evidence for microbial biomarkers of Kwashiorkor, a form of severe malnutrition. Picture, an imperative probabilistic language for 3D scene perception. Picture uses deep neural networks and statistical learning to invert generative models based on computer graphics. 50-line Picture programs can infer 3D models of human poses, faces, and other object classes from single images. Venture, an integrated platform that aims to be sufficiently expressive, efficient, and extensible for general-purpose use. It provides VentureScript, a language that gives users fine-grained control over both modeling and inference, and defines a common interface for integrating components written in other probabilistic languages. Recent applications include structure discovery from time-series via Gaussian processes and reflective AI techniques such as Bayesian optimization. Vikash K. Mansinghka MIT Vikash Mansinghka is a postdoctoral researcher at MIT, where he leads the Probabilistic Computing Project. Vikash holds S.B. degrees in Mathematics and in Computer Science from MIT, as well as an M.Eng. in Computer Science and a PhD in Computation. He also held graduate fellowships from the National Science Foundation and MIT's Lincoln Laboratory. His PhD dissertation on natively probabilistic computation won the MIT George M. Sprowls dissertation award in computer science, and his research on the Picture probabilistic programming language won an award at CVPR. He co-founded a venture-backed startup based on this research that was acquired by Salesforce.com and was an advisor to Google DeepMind. He served on DARPA's Information Science and Technology advisory board from 2010-2012, and currently serves on the editorial boards for the Journal of Machine Learning Research and the journal Statistics and Computation.
Write your own compiler in 24 hours
Write your own compiler in 24 hours by Phil Trelford (@ptrelford) Compiler writers are often seen as the stuff of myth and legend. In this session we'll step behind the proverbial curtain and reveal how compilers actually work. Expect plenty of live code samples, primarily in F#, covering language design and parsing, all-the-way through to emitting code. This session is aimed as a primer for those interested in writing an external DSL, general purpose language or just understanding how these things work. http://www.meetup.com/Norfolk-Developers-NorDev/events/205707742/
In Rust We Trust
Rust aims to build a solid foundation for building safe software systems faster. We can ensure fewer mistakes enter our code base with immutability by default, no concept of null, and proven memory safety. Rust's state of the art compiler helps developers catch errors as early as possible without paying a penalty at runtime. Developers can write high level code in a modern language without sacrificing expressiveness, development time, or execution speed. We will explore how Rust's concept of Ownership is the key to providing compile-time safety. These guarantees apply even in the face of concurrency, allowing you to easily write multi-threaded programs correctly the first time. Rust 1.0 was released May 15th. Start building better software today. Help us caption & translate this video! http://amara.org/v/HdB0/
OpenCV and High-Performance Vision on GPU
Microsoft Computer Vision Summer School 2011. Talk by Victor Eruhimov about OpenCV.
Making Games at Runtime with Clojure
Games are a modern art form, and like other artists, game designers need to experience their work as they create it. This talk will explore the benefits of making games "at runtime". Through both abstract discussion and concrete demonstration, we will see why Clojure is uniquely suited to the task. Zach is an independent programmer and tutor in the Pittsburgh area. He made Nightcode, a Clojure IDE for beginners, and is working to make Clojure games a reality with the play-clj library and Nightmod, a game creation tool. Previously, he was a programmer at the National Security Agency in Maryland.
Pragmatic Type Erasure: Solving OOP Problems Elegant Design Pattern
http://www.cppcon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- There are numerous, serious OOP design problems that we have all encountered in production code. These include, among others: - object lifetime/ownership - how to make classes from different class hierarchies conform to a common interface - writing classes that can present multiple interfaces - separating interface and implementation - how to write virtual functions so that subclasses override them properly - the virtual inheritance "diamond of death" Proper use of type erasure can mitigate, or outright eliminate, these and other problems, without sacrificing performance. This talk will cover the OOP design problems above and more, and will cover hand-rolled and library-based type erasure approaches that solve those problems. Performance metrics will be provided for the different approaches, and source code will be available after the talk. -- Zach Laine has been using C++ in industry for 11 years, focusing on data visualization, numeric computing, games, generic programming, and good library design. He finds the process of writing bio blurbs to be a little uncomfortable. -- Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
"You can be a kernel hacker!" by Julia Evans
Writing operating systems sounds like it's only for wizards, but it turns out that operating systems are written by humans like you and me. I'm going to tell you what a kernel is and why you should care. Then we'll talk about a few concrete ways to get started with kernel hacking, ranging from the super-easy to the terrifyingly difficult. by Julia Evans (@b0rk) - Stripe Julia Evans loves taking apart systems to find how they work, making Serious Computer Programs do silly things, and organizing outreach events to make our developer communities a better place. She works on Stripe's data team.
The Myth of the Genius Programmer
Google I/O 2009 - The Myth of the Genius Programmer Brian Fitzpatrick, Ben Collins-Sussman A pervasive elitism hovers in the background of collaborative software development: everyone secretly wants to be seen as a genius. In this talk, we discuss how to avoid this trap and gracefully exchange personal ego for personal growth and super-charged collaboration. We'll also examine how software tools affect social behaviors, and how to successfully manage the growth of new ideas. For presentation slides and all I/O sessions, please go to: code.google.com/events/io/sessions.html
Keynote GoingNative 2012 C++
We know how to write bad code: litter our programs with casts, macros, pointers, naked new and deletes, and complicated control structures. Alternatively (or additionally), we could obscure every design decision in a mess of deeply nested abstractions using the latest object-oriented programming and generic programming tricks. Then, for good measure, we might complicate our algorithms with interesting special cases. Such code is incomprehensible, unmaintainable, usually inefficient, and not uncommon. But how do we write good code? What principles, techniques, and idioms can we exploit to make it easier to produce quality code? In this presentation, I make an argument for type-rich interfaces, compact data structures, integrated resource management and error handling, and highly-structured algorithmic code. I illustrate my ideas and guidelines with a few idiomatic code examples. I use C++11 freely. Examples include auto, general constant expressions, uniform initialization, type aliases, type safe threading, and user-defined literals. C++11 features are only just starting to appear in production compilers, so some of my suggestions are conjecture. Developing a "modern style," however, is essential if we don't want to maintain newly-written 1970s and 1980s style code in 2020. This presentation reflects my thoughts on what "Modern C++" should mean in the 2010s: a language for programming based on light-weight abstraction with direct and efficient mapping to hardware, suitable for infrastructure code.
David Beazley - Modules and Packages: Live and Let Die! - PyCon 2015
"Speaker: David Beazley All Python programmers use the import statement, but do you really know how it works and what it allows? This tutorial aims to take a deep dive into every diabolical issue related to modules, packages, and imports. When we're done, you'll finally be ready to unleash your million line micro framework on the world! Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Justin Schneck - Enhanced Embedded Systems with Nerves (ElixirConfEU 2016)
Slides and more info: http://www.elixirconf.eu/elixirconf2016/justin-schneck Nerves defines an entirely new way to build embedded systems with Elixir that could revolutionize an industry. Imagine booting to the BEAM VM in just a few seconds with your Elixir app in control of the entire system. Nerves makes this possible while replacing the traditional plethora of Linux init scripts or systemd configuration files with a toolchain that is delightful to use. The Nerves philosophy is that you already have a powerful, concurrent language to define what the system should do at start-up time: Elixir. Together, we'll explore the principles Nerves uses to create embedded systems that control 3d printers, power unmanned areal vehicles, and more. You'll see first-hand how Nerves can support service discovery, hot code swapping, and collaboration through PubSub messages and mesh networking. Finally, we will explore the Nerves development life-cycle; from running ExTest, to deployment and hot code reloading. Talk objectives * Introduce developing embedded systems in Elixir using Nerves * Explore the Nerves development life-cycle * Demonstrate autonomous robotics using service discovery and messaging * Execute tests, create user interfaces with Phoenix, and perform hot code updates Target audience Creating devices and systems which enhance our environment is fundamental to our nature. The exploration into creating hardware that runs Elixir is geared toward the maker in all of us. Join us for an exciting demonstration into the creation of enhanced embedded systems with Elixir and Nerves. Justin started his career as a recording engineer spanning several years in the early 2000’s. He transitioned to programming C++ apps in the public sector of local government in 2005 and eventually came to master iOS development while working for an interactive marketing company. During this time, he gained a passion for embedded systems, sparked from his love of riding motorcycles. Over the years, Justin has worked on a plethora of embedded projects from iPhone motorcycle starters to advanced brewing and distilling equipment. Recently, Justin founded Metasphere, an embedded software company primarily focused on building Bakeware and Nerves. Github: mobileoverlord Twitter: @mobileoverlord
An End to Negativity - Chris Williams - JSConfEU 2011
This talk is from 2011 jsconf.eu. For reuse of this video under a more permissive license please get in touch with us. The speakers retain the copyright for their performances.
Why we have too few women leaders
Facebook COO Sheryl Sandberg looks at why a smaller percentage of women than men reach the top of their professions -- and offers 3 powerful pieces of advice to women aiming for the C-suite.
"Pixie - A Lightweight Lisp with 'Magical' Powers" by Timothy Baldridge
This will be an overview of the Pixie programming language. We will start with a few words about the niche that Pixie is trying to fill and then move on to the main features of the language, including: excellent C interop, immutable data structures, lightning-fast startup times, "good-enough" execution performance, and async-by-default io. We will also touch briefly on the technology (RPython) that has enabled Pixie to grow from nothing to a usable language in less than a year, and yet still support the major *nix OSes as well as run on x86 and ARM. Timothy Baldridge COGNITECT @timbaldridge Timothy is a developer with Cognitect Inc. He hails from the mountain regions of Denver Colorado (USA). Timothy is a polyglot programmer with experience in Clojure, C#, Python, and Erlang. He's the author of the Pixie Language and Clojure's core.async 'go' macro.
Implementing Domain Specific Languages with LLVM
FOSDEM (Free and Open Source Development European Meeting) is a European event centered around Free and Open Source software development. It is aimed at developers and all interested in the Free and Open Source news in the world. Its goals are to enable developers to meet and to promote the awareness and use of free and open source software. More info at http://fosdem.org
Make awesome command line apps with ruby by Dave Copeland
Tired of maintaining your one-off script that has now become someone's job to execute? Wishing you could create polished applications on the command line similar to git or cucumber? In my talk, I'll talk about what makes a command line application "awesome", and why you should care. I'll talk about what makes Ruby particularly suited to this task over mainstays like bash and Perl. We'll compare and contrast several Ruby libraries that can make even your lowliest automation script a polished, maintainable, and predictable application.
"Writing a game in Haskell" by Elise Huard
golang, practical Go Programming
Go is a new open-source programming language with an emphasis on simplicity, comprehensibility, and efficiency. It has the speed and safety of a statically-typed language and the lightweight feel of a scripting language. It has a simple feature set that is easy to understand and powerful to use, including a novel type system and concurrent programming primitives. This talk will dive into some real-world Go programs and discuss the Go idiom used in each. FOSDEM (Free and Open Source Development European Meeting) is a European event centered around Free and Open Source software development. It is aimed at developers and all interested in the Free and Open Source news in the world. Its goals are to enable developers to meet and to promote the awareness and use of free and open source software.
[JSConfEU 2010] Chris Williams: community.js
This talk is from 2010 jsconf.eu. For reuse of this video under a more permissive license please get in touch with us. The speakers retain the copyright for their performances.
Slightly Advanced Python: Some Python Internals
Google Tech Talks July 1, 2008 ABSTRACT "Python behind the scenes": some advanced aspects of Python. The talk addresses an audience of proficient Python programmers and deals with several advanced topics: object creation: metaclasses, new, and init - attribute lookup mechanics and descriptor objects - introspection on objects, garbage collection, stack frames, tracebacks - Python bytecode inspection and alteration. Speaker: Alex Martelli
Minimizing the Slippery Surface of Failure — Jon Pretty
Scala's type system allows us to enforce compile-time constraints on our programs, and to take advantage of these constraints to help reason about our code. Yet we still frequently encounter situations where extracting a value from a map is not guaranteed to succeed, or mapping across a set of cases is not guaranteed to be exhaustive. With dependent types we can make operations like these completely safe by construction, in the process eliminating entire classes of errors, and furthermore we can do this without complicating user code. Additionally, with more precise type information becoming available at compile time, we elicit the exciting opportunity to use it to optimize performance at runtime, beyond what would be possible without dependent typing. The talk will cover several simple and intermediate examples using dependent types, and will give a brief outline of some of the the challenges involved in implementing typesafe libraries with dependent types in Scala, but the majority of the talk will be accessible to all Scala users.
Philip Wadler: Church's Coincidences
Philip Wadler, Professor of Theoretical Computer Science at the University of Edinburgh, contends that the foundations of computing lay in a coincidence: Church's lambda calculus (1933), Herbrand and Godel's recursive functions (1934), and Turing's machines (1935) all defined the same model of computation. He gave this lecture on the occasion of Princeton University's centennial celebration of Alan Turing. Learn more at www.princeton.edu/turing #turingprinceton
ECMAScript 6 & Web Components • Brian LeRoux
Guido van Rossum on Type Hints at PyCon 2015
Guido van Rossum, creator of the Python programming language, discusses type hinting in Python 3.5. With type hinting, programmers can use type annotations to provide tools like type checkers and IDEs with more information about the expected types of values and enable better static analysis. This talk was organized by the Bay Area Python Interest Group and held at LinkedIn on March 26, 2015.
Living in the Matrix with Bytecode Manipulation
Recorded at SpringOne2GX 2014. Speaker: Ashley Puls, New Relic Slides: http://www.slideshare.net/SpringCentral/bytecode-spring2gx2014 With Spring and Hibernate on your stack, your application's bytecode is likely enhanced or manipulated at runtime. This session examines three common byte code manipulation frameworks: ASM, CGLib, and Javassist (Java Programming Assistant). We will discuss how these tools work and why frameworks like Spring use them. You will learn enough to begin integrating these frameworks directly into your own code.
My Python's a little Rust-y
"Speaker: Dan Callahan Rust is a new systems programming language from Mozilla that combines strong compile-time correctness guarantees with fast performance... and it plays nice with ctypes! Come learn how you can call Rust functions from Python code and finally say goodbye to hacking C! Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Garrett Smith - Why The Cool Kids Don't Use Erlang
Erlang is ideally suited building scalable, fault tolerant systems with minimal investment. It can be used for any conceivable application - not just telecom. It has a multi-decade track record of success. So why does it remain a niche technology? To answer this question, Garrett turned to science. He conducted a detailed survey across a wide spectrum of programmers, architects, and managers to gather data on this question. In this talk, Garrett will present his findings and reflect on what they could mean for Erlang and its community. Erlang adoption is important. It makes your job easier when Erlang is supported by your company and customers. It's easier to grow teams when there are more Erlang programmers. The language itself will improve as it is applied across more domains. If you're interested in this topic - and want data rather than personal opinions - join Garrett in this important discussion. Talk objectives: - To present data to better understand how Erlang is used and, more importantly, how and why Erlang is not used. Target audience: - Anyone interested in supporting and promoting Erlang adoption, either within their company or within the broader programming community.
CppCon 2014: Mark Maimone "C++ on Mars: Incorporating C++ into Mars Rover Flight Software"
http://www.cppcon.org -- Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- One of the more challenging aspects of developing flight software (FSW) for NASA's Spirit and Opportunity Mars Exploration Rovers (MER) and Curiosity, the Mars Science Laboratory rover was how to enable them to drive themselves safely through unknown Martian terrain. When the MER mission was approved in the year 2000, JPL researchers had already demonstrated that capability on prototype rovers  using software written primarily in C++ on a VxWorks realtime O/S platform with shared memory. So when asked to incorporate that capability into the MER vehicles which also relied on a similar VxWorks realtime O/S, the team concluded it would be safest and most expedient to incorporate the already field-tested C++ software. But that presented a challenge, since at that point all rover FSW development was mandated to be done mainly in the C programming language. In this talk we present some of the challenges we faced and solutions we found in deploying C++ onto the Mars Rovers. For example, dynamic allocation was initially precluded, but development of a specialized memory allocator (using the C++ "placement new" operator) enabled us to incorporate it safely into the flight system. We will discuss what aspects of C++ were incorporated, what simulation environments aided development, describe some of the tools used to validate system behavior, and explain how our success using C++ for the implementation of autonomous navigation on MER has influenced future FSW efforts.  Jeffrey Biesiadecki, Mark W. Maimone, and Jack Morrison., "The Athena SDM Rover: A Testbed for Mars Rover Mobility," June 2001 iSAIRAS conference proceedings, Montreal, Canada., june 2001. -- Mark Maimone is a Navigation and Machine Vision researcher at JPL.Mark designed and developed the autonomous vision and navigation software that lets the MER and MSL Mars Rovers drive themselves safely, and wrote ground software that automated the analysis of Mobility and arm operations on MER.Mark is now a Rover Driver for Curiosity, and he continues to develop and enhance the onboard autonomous vision and navigation software for the rovers.Mark earned his Ph.D. in Computer Science at Carnegie Mellon University in 1996, and completed a postdoc there in 1997 as Navigation and Software Lead for the 1997 Atacama Desert Trek.At JPL since 1997, Mark has also worked on the Long Range Science Rover, Planetary Dexterous Manipulator, and Pioneer Vision System for Chornobyl Inspection projects, delivering 3D vision systems for autonomous robotic operations and mapping.Website: http://www-robotics.jpl.nasa.gov/people/Mark_Maimone/ -- Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Eric Shull: Communicating Sequential Processes (September 22, 2015)
The time has come to think concurrently. Traditional software concurrency management leads to non-deterministic race conditions and deadlocks that are hard to reproduce and debug, leading to unreliable software. That means it's time to introduce math. Tony Hoare's paradigm of communicating sequential processes, or CSP, is not only a robust way to manage concurrency, but it's fun too! Join us to learn more about how CSP in the Go programming language allows us to reason more clearly about many things happening at once. About Eric: Eric Shull is a software consultant and developer at Atomic Object. He enjoys working in Go and ClojureScript, writing, sketchnoting, doing math, creating data visualizations, making experimental programming languages, and much, much more.
The Science of Insecurity
Why is the overwhelming majority of common networked software still not secure, despite all effort to the contrary? Why is it almost certain to get exploited so long as attackers can craft its inputs? Why is it the case that no amount of effort seems to be enough to fix software that must speak certain protocols? The answer to these questions is that for many protocols and services currently in use on the Internet, the problem of recognizing and validating their "good", expected inputs from bad ones is either not well-posed or is undecidable (i. e., no algorithm can exist to solve it in the general case), which means that their implementations cannot even be comprehensively tested, let alone automatically checked for weaknesses or correctness. The designers' desire for more functionality has made these protocols effectively unsecurable. In this talk we'll draw a direct connection between this ubiquitous insecurity and basic computer science concepts of Turing completeness and theory of languages. We will show how well-meant protocol designs are doomed to their implementations becoming clusters of 0-days, and will show where to look for these 0-days. We will also discuss simple principles of how to avoid designing such protocols.
Zach Tellman - Always Be Composing
The Clojure ecosystem, we're told, is made up of small, composable libraries. In practice, though, it's all too common to find that two libraries simply will not cleanly compose. This typically will lead to another library that does the same thing, but in a subtly different way. Sometimes this is warranted, but often it's not. This talk will discuss the constraints and affordances that make a piece of code play nicely with other pieces of code. Attendees will learn how to write clean, reusable Clojure, drawing on the speaker's many past failures and few notable successes. The first place I think of, when I try to tell someone about this quality, is a corner of an English country garden, where Zach Tellman grows against a wall. The wall runs east to west; Zach grows flat against its southern side. The sun shines on him and as it warms the bricks behind Zach, the warm bricks themselves warms the peaches on him. It has a slightly dozy quality. Zach, carefully tied to grow flat against the wall; warming the bricks; the peaches growing in the sun; the wild grass growing around Zach's roots, in the angle where the earth and roots and wall all meet.
"Haste: Full-Stack Haskell for Non-PhD Candidates" by Erin Swenson-Healey and James Cooper
DConf 2014: The Last Thing D Needs (Scott Meyers)
Plain Threads are the GOTO of todays computing - Hartmut Kaiser - Keynote Meeting C++ 2014
Hartmut Kaisers Keynote from Meeting C++ 2014 Slides: http://meetingcpp.com/index.php/tv14/items/26.html
Linus Torvalds talks about GIT
Linus Torvalds visits Google to share his thoughts on git, the source control management system he created two years ago.
Optimizing Native Code for Erlang
Steve Vinoski http://www.chicagoerlang.com/steve-vinoski.html Erlang was built to be "fast enough" for most problems. But what if you need to go super fast? To turn the dial to 11? In this talk Steve will cover Erlang's turbo booster --- the *NIF*. And it's not as simple as it sounds!
"Eve" by Chris Granger
"Linux Sucks" - 2014
"Linux Sucks". 2014 edition. Recorded live at LinuxFest Northwest on April 26th, 2014. How to yell at me: Blog: http://www.lunduke.com Twitter: http://twitter.com/BryanLunduke G+: https://plus.google.com/+BryanLunduke
Scott Meyers – The Most Important Design Guideline
What’s the single most important design guideline for the creation of high-quality software? For Scott Meyers, it’s all about interface design. That includes user interfaces, of course, but also APIs, i.e., class interfaces, function interfaces, template interfaces, etc. The guideline is simple: make interfaces easy to use correctly and hard to use incorrectly, but achieving it can be challenging. In this presentation, Scott describes a number of specific ways to approach the design of high-quality interfaces. Much of the material is language- and domain-independent, but some of the ideas assume that you’re using a programming language with relatively strong static typing (e.g., C, C++, Java, C#).
Computing a theory of everything
Stephen Wolfram, creator of Mathematica, talks about his quest to make all knowledge computational -- able to be searched, processed and manipulated. His new search engine, Wolfram Alpha, has no lesser goal than to model and explain the physics underlying the universe.
Python and Julia. Why do we need another language? - Dwight J. Browne
Integration of Ipython notebook and Julia
Douglas Crockford Talks about 'Upgrading the Web' at https://AngularU.com in San Francisco
Douglas Crockford Talks about 'Upgrading the Web' at https://AngularU.com in San Francisco This talk suggests a way forward, taking inspiration from our successful transition from NTSC to HDTV. There is a way forward to a web that is safer, easier, and as good as we desire. Session Details: https://angularu.com/ng/Session/2015sf/upgrading-the-web Session Materials: http://json.org Session Photos: https://angularu.com/ng/Session/2015sf/upgrading-the-web#photos Angular U site: https://angularu.com Subscribe to the Angular U Youtube Channel https://www.youtube.com/channel/UCBWXtgwaUqyvI50euTYlUWQ Follow Angular U on Twitter: https://twitter.com/AngularU Join the Angular U G+ community: https://plus.google.com/u/1/communities/100721362580915494668
"Transducers" by Rich Hickey
People keep implementing map, filter and other fundamental algorithms in different contexts - eagerly over collections, over lazy sequences, in parallel, over enumerables/iterables, over observables, over channels/streams etc. In addition to duplication of effort, this yields bloated APIs, and, when implemented in the classic way, often involves the creation of expensive intermediate objects/values that can be difficult to optimize away. Most problematic is that this approach keeps us from composing core algorithms in a context-independent way which would facilitate reuse and engender greater flexibility. This talk will describe transducers, a new library feature for Clojure (but of interest to other languages) that emphasizes composable, context-free, intermediate-free notions like 'mapping' and 'filtering' and their concrete reuse across all of the contexts above. by Rich Hickey (@richhickey) - Cognitect Rich Hickey, the author of Clojure and designer of Datomic, is a software developer with over 25 years of experience in various domains. Rich has worked on scheduling systems, broadcast automation, audio analysis and fingerprinting, database design, yield management, exit poll systems, and machine listening, in a variety of languages. Rich is CTO of Cognitect, Inc.
[JSConfUS 2013] Adam Solove: Constraint programming in the browser
Shmoocon 2013 - C10M Defending The Internet At Scale
Microservices at Spotify
This presentation was recorded at GOTO Berlin 2015 http://gotober.com Kevin Goldsmith - Vice President, Engineering at Spotify ABSTRACT The software industry used to be all about building monoliths: monolithic applications and services, with bing-bang product releasees. All that has now changed [...] Download slides and read the full abstract here: http://gotocon.com/berlin-2015/presentation/Microservices%[email protected]%20Spotify https://twitter.com/gotober https://www.facebook.com/GOTOConference http://gotocon.com
User Interface (UX) Techniques • Janne Jul Jensen
Check out our upcoming conferences at http://gotocon.com Subscribe to the GOTO Conferences YouTube Channel at https://www.youtube.com/user/GOTOConf... Janne Jul Jensen - Interaction Designer and Usability Specialist ABSTRACT Most developers today are aware of the importance of creating a good user interface with a high level of usability, but many are lacking the methods and techniques that can help in this process. This session will present to the listeners a range of concrete methods and techniques applicable in different phases of a design process, to handle specific challenges. This will include design patterns, personas, wire framing, paper prototype testing, progressive disclosure, card sorting and creative workshops and many of the methods and techniques will be accompanied by examples. https://twitter.com/gotocon https://www.facebook.com/GOTOConference http://gotocon.com
Functional Programming; What? Why? When?
Why is functional programming becoming such a hot topic? Just what _is_ functional programming anyway? And when am I going to have to know about it? In this talk Uncle Bob will walk you through the rationale that is driving the current push towards functional programming. He'll also introduce you to the basics by walking through some simple Clojure code.
Alex Gaynor: Fast Python, Slow Python - PyCon 2014
Speaker: Alex Gaynor "The common wisdom is that Python is slow. And yet people run high performance software on it. It's hard to make Python fast, and yet there are incredibly high performance Python VMs. This talk breaks down the facts and the myths of Python performance." Slides can be found at: https://speakerdeck.com/pycon2014 and https://github.com/PyCon/2014-slides
How to build a brain with Python
Power Use of UNIX • Dan North
Check out our upcoming conferences at http://gotocon.com Subscribe to GOTO Conference's YouTube Channel at http://www.youtube.com/user/GOTOConferences?sub_confirmation=1 Dan North - Agile Troublemaker, Developer, Originator of BDD ABSTRACT Thus begins an old, and sadly lost in the mists of Usenet, love story about Vi and Ed (who becomes her "ex"), told entirely in Unix commands. I had no idea when I started learning these arcane (guess how the "dd" command got its name) and cryptic (what about "grep"?) Unix commands how incredibly useful they would become over the next two decades. If your primary OS is Linux or OSX on the desktop, and maybe iOS or Android on the move, you'll find this 40-something year joke ("Unix" itself was a bad pun) has managed to embed itself into every facet of your technological life. Being comfortable at a shell prompt and having a healthy working knowledge of Unix commands and regular expressions will give you a whole new level of capability. In this fun talk I'll introduce a few commands and shell tricks you should have in your back pocket, and show you how to start taking control of your operating system. If you ask nicely I'll even tell you about the production system I wrote using Makefiles. https://twitter.com/gotocon https://www.facebook.com/GOTOConference http://gotocon.com
PyPy.js: What? How? Why? by Ryan Kelly
What the heck is the event loop anyway?
Faith, Evolution, and Programming Languages
Google Tech Talks April 27, 2007 ABSTRACT Faith and evolution provide complementary--and sometimes conflicting--models of the world, and they also can model the adoption of programming languages. Adherents of competing paradigms, such as functional and object-oriented programming, often appear motivated by faith. Families of related languages, such as C, C++, Java, and C#, may arise from pressures of evolution. As designers of languages, adoption rates provide us with scientific data, but the belief that elegant designs are better is a matter of faith. This talk traces one concept, second-order quantification, from its inception in the symbolic logic of Frege through to the generic features introduced in Java 5, touching on features of faith and evolution. The remarkable correspondence between natural deduction and functional programming informed the design of type classes in Haskell. Generics in Java evolved directly from Haskell type classes, and are designed to support evolution from legacy code to generic code. Links, a successor to Haskell aimed at AJAX-style three-tier web applications, aims to reconcile some of the conflict between dynamic and static approaches to typing. Google EngEDU Speaker: Philip Wadler
Java 8 Lambda Expressions & Streams
The release of Java 8 brings several new features to the language. NewCircle Instructor Adib Saikali walks us through two of the most exciting additions: lambdas (2:00) and steams (1:17:44). NewCircle's Java 8 Training: http://crcl.to/37zs5 http://www.meetup.com/sfjava/
The Future of Programming
"The most dangerous thought you can have as a creative person is to think you know what you're doing." Presented at Dropbox's DBX conference on July 9, 2013. All of the slides are available at: http://worrydream.com/dbx/ For his recent DBX Conference talk, Victor took attendees back to the year 1973, donning the uniform of an IBM systems engineer of the times, delivering his presentation on an overhead projector. The '60s and early '70s were a fertile time for CS ideas, reminds Victor, but even more importantly, it was a time of unfettered thinking, unconstrained by programming dogma, authority, and tradition. 'The most dangerous thought that you can have as a creative person is to think that you know what you're doing,' explains Victor. 'Because once you think you know what you're doing you stop looking around for other ways of doing things and you stop being able to see other ways of doing things. You become blind.' He concludes, 'I think you have to say: "We don't know what programming is. We don't know what computing is. We don't even know what a computer is." And once you truly understand that, and once you truly believe that, then you're free, and you can think anything.'"
Rishiyur S. Nikhil - Enigmatic Haskell, Haskellish Enigma
Boston Haskell, February 18, 2015 Nikhil builds an Enigma machine. First in Cryptol, then in hardware by way of Haskell. Slides and code available here: https://github.com/rsnikhil/Enigma_Cryptol_Bluespec_BSV.git
Opening Keynote (Progressive Web App Summit 2016)
It's now possible to build fast, engaging, reliable mobile web experiences that are great for users and good for businesses. We'll kick off the two day summit with an overview of Progressive Web Apps as well as strategies for how you can integrate these new technologies into your own site. Subscribe to the Chrome Developers channel at http://goo.gl/LLLNvf Music by Terra Monk: https://soundcloud.com/terramonk/pwa-amsterdam-2016
Snappy Performance Apps with Ember.js
Anthony Bull believes that all MVC frameworks make trade-offs, but that Ember.js provides the best balance for developing well-factored and ambitious web applications. This talk at the SF HTML5 User Group meetup on January 31st, 2013, features: -an introduction to ember.js -comparisons to other frameworks -code to demonstrate the ember.js syntax. Find out why Anthony calls ember.js the "swiss-army-knife" of developing frameworks. **Interested in a closer look at Anthony's slides? Check them out here: http://mrkn.co/enaa6
Colton Myers: Decorators: A Powerful Weapon in your Python Arsenal - PyCon 2014
Speaker: Colton Myers Decorators are an invaluable addition to anyone's arsenal of python tools and tricks. We will learn what a decorator is, how decorators are created, and then explore some of the cooler applications for decorators in our everyday projects. Slides can be found at: https://speakerdeck.com/pycon2014 and https://github.com/PyCon/2014-slides
Solving Problems with Automata - Mark Engelberg & Alex Engelberg
Many of us have hazy memories of finite state machines from computer science theory classes in college. But finite state machines (FSMs) have real, practical value, and it is useful to know how to build and apply them in Clojure. For example, FSMs have long been popular to model game AIs and workflow rules, and FSMs provide the behind-the-scenes magic that powers Java's regexes and core.async's go blocks. In this talk, we'll look at two programming puzzles that, suprisingly, have very elegant solutions when looked at through the lens of FSMs, with code demonstrations using two different Clojure libraries for automata (automat and reduce-fsm), as well as loco, a Clojure constraint solver. About the speakers: Mark Engelberg has been an active member of the Clojure community ever since Clojure turned 1.0, and is the primary developer of math.combinatorics, math.numeric-tower, data.priority-map, ubergraph, and a co-developer of instaparse. By day, he teaches Scheme and Clojure to talented kids in the Seattle area; by night, he creates logic puzzles and games, using Clojure as his "secret weapon". His latest game is Code Master, a programming-themed puzzle game for kids, available exclusively at Target (and created with Clojure, of course!) Alex Engelberg was indoctrinated by his father in the ways of functional programming at a young age, and Clojure rapidly became his language of choice. He is happy to be using Clojure professionally as a software engineer at SecureOne in Seattle. Alex also enjoys contributing to open source; he is the primary developer of loco, and co-developer of instaparse.
Don't Help the Compiler
Day 1 - C++ has powerful rules for dealing with low-level program structure. Before a program is ever executed, the compiler determines valuable information about every expression in the source code. The compiler understands exactly how long each object's resources will be needed (lifetime), whether each expression refers to an object that the program has no other way of accessing (rvalueness), and what operations can be performed on each object (type). Using examples from C++98 through C++14, this presentation will demonstrate how to write code that works with the compiler's knowledge to increase robustness, efficiency, and clarity. This presentation will also demonstrate the horrible things that happen when programmers think they can do tasks that are better left to compilers.
Thomas Pfaff: Advanced Data Storage
In this tutorial we will give an introduction to two advanced data storage formats. HDF5 and NetCDF were designed to efficiently store the results of supercomputing applications like climate model outputs, or the data streams received from NASA's fleet of earth observing satellites. They provide a lot of optimizations concerning transparent file compression, speed of access or working with multiple files as if it were one large data set.A couple of Python libraries exist that allow fast and pythonic access to these formats.We will show you how to create and access these types of files from Python, and how to use their advanced features to tune them for maximum efficiency.Tutorial prerequisites and instructions. Thomas Pfaff
Python Metaprogramming for Mad Scientists and Evil Geniuses
Walker Hale This talk covers the power and metaprogramming features of Python that cater to mad scientists and evil geniuses. This will also be of interest to others who just want to use of Python in a more power (hungry) way. The core concept is tha
Free software, free society
It is the first TEDx talk of the founder of Free Software movement. Stallman, RMS for short, has changed the world with his vision of freedom for the digital age. He launched the GNU operating system, used with Linux as a component, and inspired the development of Creative Commons licences and Wikipedia project. In this talk, Stallman describes how nonfree programs give companies control of their users and what users can do in order to recover control over their computing.
"Controlling Time and Space: understanding the many formulations of FRP" by Evan Czaplicki
Functional Reactive Programming (FRP) is becoming an increasingly common way to structure event- driven code, but the term "FRP" actually refers to a large body of increasingly diverse work. This talk will quickly cover the basics of FRP, and then go into a couple different formulations of FRP that people are beginning to use. We will explore how these formulations fit together historically and theoretically. Finally, we will see how the particular variation of FRP used in Elm makes it easy to implement hot- swapping and Elm's Time Traveling Debugger. by Evan Czaplicki (@czaplic) - Prezi I am a functional programmer at heart, and my broad goal is to provide the tools and learning resources to make functional languages common in industry. I develop Elm 's compiler, tools, and community to make it great for projects within Prezi and in industry in general.
DConf 2014: SDC, a D Compiler as a Library by Amaury Sechet
The D Programming Language Conference, May 21-23 2014, Menlo Park, CA.
Clojure: Clojure Library Core.async for Asynchronous Programming
Paul Tagliamonte: Getting Hy on Python: How to implement a Lisp front-end to Python - PyCon 2014
Speaker: Paul Tagliamonte This talk will cover the internals of Python, such AST, Import hooks, creating a console, and a very brief overview of Python internal formats (such as pyc files), by way of looking over the implementation of a Lisp called "Hy". No Lisp knowledge is required. Slides can be found at: https://speakerdeck.com/pycon2014 and https://github.com/PyCon/2014-slides
Functional programming patterns for the non-mathematician (cut)
I hit on some practical use cases for functors/applicatives/monads. Pretty fast and quick run through of everything, but you can't learn the world in 30 min. Hopefully, people get some intuition or a better concrete understanding - enough to play with the code. here github.com/DrBoolean/patterns_talk
Lawful Asynchronous Programming — Daniel Spiewak
Laws are our friends! They make it easier to reason about things by eliminating possibilities and constraining the problem space. Applying lawful, principled and reasonable programming to the thorny problem of asynchronous and concurrent systems seems like a natural fit, but the devil is in the details. This talk will explore scalaz-stream, both the present and the future designs at a very low-level. We'll look at where we can apply lawful reasoning and where we can't. We'll also examine some of our past failures in this area, and how we think we can do better in upcoming releases.
Small Is Beautiful
Systems get bigger, technologies reach further, practices mature, advice changes... or at least some of it does. Some guidance remains unaffected by the passing of paradigms, the evolution of technology or the scaling of development: break your software into small, cohesive parts defined by clear interfaces and sound implementations, all the while striving for simplicity. The excuses for not doing so are as predictable as they are problematic. But if you want to create legacy code, make sure code is arbitrarily partitioned into large, incoherent parts characterised by unwieldy interfaces and incomprehensible implementations. While there are many definitions of what a legacy system is, common to almost all perceptions of a legacy system is the concept of size — specifically, lots of it. The phrase 'small legacy system' can be considered an oxymoron. This talk sets out to re-assess and reassert the importance of thinking and implementing small as an essential property of software systems — yes, even the large ones.
Advanced C Coding For Fun!
Presenter(s): Rusty Russell URL: http://2011.linux.conf.au/programme/schedule/view_talk/190 While working on CCAN I realised just how many C coding tricks there are. Regrettably, we spend very little time reading completely foreign code and instead we collect techniques one by one over years. It needn't be that way: this presentation is a cookbook with examples of all the C programming tricks I have found value in. Not just the basics like valgrind, talloc and the Jenkins hash, but less sane techniques like typesafe callbacks, runtime code updating, C as a scripting language and malloc failure path testing. Everyone who codes in C will get something out of this talk. http://2011.linux.conf.au/ - http://www.linux.org.au CC BY-SA - http://creativecommons.org/licenses/by-sa/4.0/legalcode.txt
C++17: I See a Monad in Your Future
Abstract The introduction of lambdas and first class function objects forever changed the nature of C++, opening up the floodgates to functional programming. Sometimes the best library design is based on a pattern that's very familiar to a Haskell programmer but alien to a C++ programmer. The new std::future proposal for C++17 hides several functional patterns including that of a monad -- the boogeyman of generations of imperative programmers. But once seen in action, the monad becomes just one more pattern in the toolbox of a library designer. Bio Bartosz Milewski always tries to be where the action is. He started as a quantum physicist when supertstrings were hot, joined the software industry to build the search engine for Microsoft Windows, became an avid proponent of object-oriented programming, and wrote a book on C++. He got into concurrency and parallelism when the multicores hit the market, and now he's evangelizing functional programming as the Holy Grail of software development.
JVMLS 2015 - VM Design Choices
JVMLS 2015 - VM Design Choices - Cliff Click The JVM Language Summit is an open technical collaboration among language designers, compiler writers, tool builders, runtime engineers, and VM architects. In 2015, it convened at Oracle's Santa Clara, CA campus on August 10-12.
Speed & Scale: How to get there • Adrian Cockcroft
This presentation was recorded at GOTO Chicago 2014 http://gotochgo.com Adrian Cockcroft - Technology Fellow at Battery Ventures and Former Netflix Cloud Architect Pioneer ABSTRACT To deliver software products at high velocity requires four things. First, a culture of innovation that can see and respond to opportunities. Second, the data and analytics to evaluate alternatives. Third, a culture that can make decisions and assign resources quickly. Fourth, agile development and self service deployment. A fine grain loosely coupled architecture scales as the team size grows, a freedom and responsibility culture provides autonomy for innovation and fast decision making, unstructured "Big Data" analytics gets answers quickly, cloud removes the latency of resource allocation, and DevOps removes the coordination latency that slows down deployment. Traditional enterprise architectures are based on monolithic applications and relational databases. Cloud native architectures are based on buiding single function REST-based microservices that support integration across denormalized NoSQL data stores and a wide range of web services. This talk will also discuss strategies, patterns and pathways to perform a gradual migration towards cloud native. Link to slides: http://gotocon.com/dl/goto-chicago-20... https://twitter.com/gotochgo https://www.facebook.com/GOTOConference http://gotocon.com
CppCon 2014: James McNellis & Kate Gregory "Making C++ Code Beautiful"
http://www.cppcon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- Ask a non-C++ developer what they think of C++ and they'll give the language plenty of compliments: powerful, fast, flexible, and "the language for smart people". But along with that you are likely to hear ugly, complicated, hard to read, and "the language for smart people". Is it possible to write beautiful C++? Not arcanely elegant or wickedly compact, but readable, clear, expressive - beautiful! We say it is, and we want to show you how. In this session, you'll see how to turn pages of "comic book characters swearing" into code you'll be proud to call your own. By making your code express your intent, using the power of new language and library functionality, and leaving hard-to-read constructs out of your vocabulary, you can give your code a makeover that will stand the test of time. -- James McNellis is a senior engineer on the Microsoft Visual C++ team, where he is responsible for the Visual C++ C Runtime (CRT) and C Standard Library implementation. He was previously a member of the Microsoft Expression Blend team, developing the XAML designer tools for Windows 8 apps. Prior to joining Microsoft in 2010, he spent several years working on real-time 3-D simulation and robotics projects in the defense industry. James is a prolific contributor on the Stack Overflow programming Q&A website and occasionally writes for the Visual C++ Team Blog. He tweets at @JamesMcNellis and can be found elsewhere online via http://www.jamesmcnellis.com. -- Kate Gregory has been using C++ since before Microsoft had a C++ compiler. She writes, mentors, codes, and leads projects, in both C++ and .NET, especially for Windows 7 and 8. Kate is a Microsoft Regional Director, a Visual C++ MVP, and has written over a dozen books (the most recent on C++ AMP for Microsoft Press) and speaks at conferences and user groups around the world. Kate develops courses on C++, Visual Studio, and Windows programming for Pluralsight, founded the East of Toronto .NET Users group, and is a member of adjunct faculty at Trent University in Peterborough.Website: http://www.gregcons.comTwitter handle: @gregcons -- Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Atmosphere 2013: "Your CSS is a Mess" Jonathan Snook (Shopify)
We would like to thank everyone for attending the first edition of Atmosphere Conference, which was held on the 13th-14th May 2013 in Concordia Design in Poznan. Considering the fact that the event was organised for the first time, we must admit that there was a great number of attendees interested in web scalability and performance. Together with organisers we managed to gather over 200 people. Two tracks of lectures, interviews and thousands of conversations behind the scenes guaranteed a successful conference, which we are proud to be organisers of. We hope that this event has met your expectations and gave you a chance to exchange experience, establish cooperation and meet people with similar interests. The first edition of Atmosphere would not be possible if not a great partners' support. Main Partner was the Allegro Group, which has also helped us create the conference schedule. Gold Sponsors were Akamai Technologies and Cisco Systems, whereas Silver Sponsor was the Dell Company. We would also like to thank our media partners, online services and bloggers who helped us promote the event. Photos, presentations and videos will be available soon on the website. Once again - thank you all for creating the first edition of Atmosphere Conference and see you next year.
Is Node.js Better?
How do we resolve the question, "is this better than that?" This talk discusses ideas for improving how we handle conflict in the programming community through the lens of evaluating whether Node.js is better than other technologies like Ruby.
Writing Quality Code in Erlang
Garrett Smith http://www.chicagoerlang.com/garrett-smith.html We all know that one of Erlang's greatest weaknesses is its syntax. It doesn't resemble Ruby at all! In this talk Garrett will show how Erlang can be used to write high quality, beautiful code. That is, code that's readable, maintainable and that obviously reflects the intent of its author.
CppCon 2014: Herb Sutter "Lock-Free Programming (or, Juggling Razor Blades), Part II"
http://www.cppcon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- Example-driven talk on how to design and write lock-free algorithms and data structures using C++ atomic -- something that can look deceptively simple, but contains very deep topics. (Important note: This is not the same as my "atomic Weapons" talk; that talk was about the "what they are and why" of the C++ memory model and atomics, and did not cover how to actually use atomics to implement highly concurrent algorithms and data structures.) -- Herb Sutter: Author, chair of the ISO C++ committee, software architect at Microsoft. -- Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Rich Hickey: Deconstructing the Database
Rich Hickey, author of Clojure, and designer of Datomic presents a new way to look at database architectures in this talk from JaxConf 2012. ** For more presentations from JaxConf 2012, head to http://mrkn.co/txtch
David Beazley: Generators: The Final Frontier - PyCon 2014
Speaker: David Beazley Python generators have long been useful for solving all sorts of problems involving iteration and data flow. However, one of their more powerful uses is in customizing various aspects of program control flow. In this tutorial, we'll look at some more exotic uses of generators such as writing context managers, inlining callback functions, eliminating recursion, implementing actors, and more. Slides can be found at: https://speakerdeck.com/pycon2014 and https://github.com/PyCon/2014-slides
"Side Effects are a Public API" by Christopher Armstrong
Haskellers have been isolating their side-effects from their pure code for decades, but most people write code in languages that allow ad hoc side-effects anywhere. In a lot of cases, these side-effects are practically a part of the public API -- they put restrictions the way the code can be used, often obscurely, and have effects that are observable to the caller. It helps a lot to acknowledge this and explicitly treat them as a part of your public API. Here are the basic ideas that I'll cover: represent your side-effects as "intents to perform an action" -- transparent objects that expose the details of the side-effect, without actually performing it combine effects with pure code to describe the execution order and data dependencies (yes, like a monad) write unit tests for your code without mocking, by specifying the expected content, results, and order of side-effects performed by a function I'll show a library implemented for Python, called Effect, that provides tools for doing this. A lot of these ideas are similar to the Extensible Effects system described for Haskell, and I'll describe some ideas and techniques that even most Haskellers could use to make their code more easily testable. Christopher Armstrong RACKSPACE @radix Christopher Armstrong is a long-time writer of Python code, who recently immersed himself in the world of purely functional programming. He is a long-time contributor to the Twisted networking framework, and more recently has been working on the Effect library. He is also a budding Haskell enthusiast.
Refactoring from Good to Great
Most developers know enough about refactoring to write code that's pretty good. They create short methods, and classes with one responsibility. They're also familiar with a good handful of refactorings, and the code smells that motivate them. This talk is about the next level of knowledge: the things advanced developers know that let them turn good code into great. Code that's easy to read and a breeze to change. These topics will be covered solely by LIVE CODING; no slides. We'll boldly refactor right on stage, and pray the tests stay green. You might even learn some vim tricks as well as an expert user shows you his workflow. Topics include: The Open-Closed Principle The types of coupling, and their dangers Why composition is so damn great A powerful refactoring that Kent Beck refers to as "deep deep magic" How to destroy conditionals with a NullObject The beauty of the Decorator pattern Testing smells, including Mystery Guest and stubbing the system under test The stuff from the last halves of Refactoring and Clean Code that you never quite got to.
LambdaConf 2015 - Make Your Own Programming Language! Nick Heiner
We're all used to typing code into an editor and seeing the computer do something when we run it. This is so familiar that it's easy to take for granted. How do we go from a sequence of characters to something the machine can execute? Knowing this will not only help you program more effectively, but it will empower you to create your own programming languages. I'll give an overview of the pipeline from your text editor to the machine's behavior. Then, we'll dive in and look at specific tools that will help us create our own programming language. We'll also discuss different language design decisions, such as static versus dynamic typing, and see how they are implemented behind the scenes. By the end, you'll be ready to bring your new language into the world!
Functional programming - Bodil Stokke
Build Your Own Lisp for Great Justice Implementing a toy Lisp interpreter is practically a rite of passage for the budding computer scientist. This hallowed tradition is described in detail in "Lisp in Small Pieces," the seminal work on the making of Lisps, but everybody loves a tl;dr, so let's do the 40 minute executive summary. We'll charge at high speed through the following topics, with Clojure code to follow along with as we go (because there's no better language for implementing a Lisp than another Lisp): * Parsing: turning text files into ASTs * Fundamental Lisp datatypes * McCarthy's elementary functions * Evaluating Lisp code * Lambdas and lexical scope * Your friend, the state monad * Beyond Lisp: pattern matching and type systems When we're done, you'll be ready to go forth and fill the world with Lisps of all shapes, colours and Greenspun violations for Great Justice. Also, it'll be good fun. Speaker Bodil Stokke (@bodil) is a compulsive conference speaker in the fields of functional programming and internets technologies, and is a co-organiser of three annual developer conferences in her home town of Oslo, Norway, mostly because she's still learning how to stop. She is a prolific contributor to the Free Software community, primarily as a Clojure developer, and has recently taken up designing new programming languages as a hobby. In her spare time, she works as a web developer for Comoyo, which is like Hulu for non-Americans.
David Nolen - The Functional Final Frontier
The Model-View-Controller (MVC) approach to user interfaces was first proposed by Trygve Reenskaug in a 1979 Xerox PARC note. As Object Oriented methodologies gained popularity, MVC too gained traction as a natural and logical way to construct user interfaces despite obvious shortcomings. Even though OO researchers moved forward with alternative approaches likes Morphic and constraint based systems, MVC today maintains a stranglehold on mainstream developer approaches to UI. Can functional programming take the good lessons from MVC while advancing the state of the art? Functional Reactive Programming and its derivatives primarily solve complexities around events - what of component modularity and abstraction? We'll examine how a new library for ClojureScript called Om, a simple functional layer over Facebook's React, makes some traditional hard problems in MVC based UIs simple without abandoning the abstractions OO programmers find so useful. These concepts are easily portable to other systems provided the presence of persistent data structures.
Ashley Williams: If you wish to learn ES6/2015 from scratch, you must first invent the universe
Jafar Husain discusses interesting features that can be used today in JS6, such as Object.observe, async functions and async generators, while also giving a peek at what's being explored for JS7 to make async programming easier.
CODE GENIUS - Rise of the Transpilers by Jeremy Ashkenas
New York Times graphics editor, Jeremy Ashkenas, presents at Code Genius. 4/23/15 Follow Jeremy Ashkenas: @jashkenas www.ashkenas.com Visit code.genius.com for more information about past events and upcoming talks Presented by Genius GENIUS.COM
ElixirDaze 2016 - Keynote: New Heights by Chris McCord
Keynote: New Heights by Chris McCord Help us caption & translate this video! http://amara.org/v/IDIZ/
Functional programming design patterns by Scott Wlaschin
In object-oriented development, we are all familiar with design patterns such as the Strategy pattern and Decorator pattern, and design principles such as SOLID. The functional programming community has design patterns and principles as well. This talk will provide an overview of some of these, and present some demonstrations of FP design in practice.
Losing your Loops Fast Numerical Computing with NumPy
The Birth of the Computer
Historian George Dyson tells stories from the birth of the modern computer from its 16th-century origins to the hilarious notebooks of some early computer engineers.
Raymond Hettinger - Super considered super! - PyCon 2015
"Speaker: Raymond Hettinger Python's super() is well-designed and powerful, but it can be tricky to use if you don't know all the moves. This talk offers clear, practical advice with real-world use cases on how to use super() effectively and not get tripped-up by common mistakes. Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Loop like a native: while, for, iterators, generators
Ned Batchelder Python provides powerful primitives for iterating over your data in ways that let you express yourself clearly and directly. But even programmers familiar with the tools don't use them as fully as they could. This talk will cover Pyt
Kenneth Foner - Getting a Quick Fix on Comonads
Kenneth Foner's Comonad talk at the Boston Haskell meetup, September 17, 2014. Code and slides: https://github.com/kwf/ComonadSheet
CSS Performance Tooling
DConf 2014 Day 2 Talk 2: Refactoring JIT Compilation by Maxime Chevalier-Boisvert
Miguel Grinberg: Flask by Example - PyCon 2014
Speaker: Miguel Grinberg Flask is a web framework for Python based on Werkzeug, Jinja 2 and good intentions. It is considered a micro-framework, but don't get the "micro" part fool you; Flask can do everything others can do, many times in a simpler, leaner way. In this tutorial session you will follow me as I write a complete web application in front of your eyes using the core framework and a handful of extensions. Slides can be found at: https://speakerdeck.com/pycon2014 and https://github.com/PyCon/2014-slides
"How we stopped SOPA"
Aaron Swartz keynote - "How we stopped SOPA" at F2C:Freedom to Connect 2012, Washington DC on May 21 2012. http://freedom-to-connect.net/
Philip Wadler - Everything old is new again: Quoted domain specific languages - Curry On
Curry On Prague, July 7th, 2015 http://curry-on.org http://2015.ecoop.org
Debugging with the Scientific Method - Stuart Halloway
About the speaker: Stuart Halloway (@stuarthalloway) is a founder and President of Cognitect (formerly Relevance). He is a Clojure committer, and a developer of the Datomic database. Stuart has spoken at a variety of industry events, including Strange Loop, Clojure/conj, EuroClojure, ClojureWest, SpeakerConf, QCon, GOTO, OSCON, RailsConf, RubyConf, JavaOne, and NFJS. Stuart has written a number of books and technical articles. Of these, he is most proud of Programming Clojure.
LambdaConf 2015 - Full stack FP in Datomic, Clojure, and ClojureScript Priyatam Mudivarti
What happens when we prototype an app entirely in FP? From choosing a functional database to building http apis and designing templates and stylesheets—it is possible these days, to stay entirely in FP land! In this talk I will share my experience in building functional prototypes with Clojure & Clojurescript using the following libraries: Datomic, Ring, Om, and Garden. I’ll discuss how we can trade popular databases, web toolkits, template engines, and even less and sass in favor of simpler libraries that embrace immutable data as a “Sequence of Values”.
Thomas Suarez: A 12-year-old app developer
Most 12-year-olds love playing videogames — but Thomas Suarez taught himself how to create them. After developing iPhone apps like "Bustin Jeiber," a whack-a-mole game, he is now using his skills to help other kids become developers.
Computer science is for everyone
This persuasive talk shows how essential and easy it is to gain a basic understanding of computer science learning principles. Our world increasingly driven by technology and software, so we all need to know the creative, problem-solving power of computer science. This is especially important to students who will lead the way in our shared future. Learn how you can take the next step at http://code.org.
One Hacker Way
This presentation was recorded at GOTO Copenhagen 2015 http://gotocph.com Erik Meijer - Founder at Applied Duality, Inc. ABSTRACT Erik challenges the basic ideas on Scrum & Agile and how developers should be developing code for the future. In the next decade every business will be digitized and effectively become a software company. Leveraging software, and, in general, computational [...] Download slides and read the full abstract here: http://gotocon.com/cph-2015/presentation/Keynote:%20One%20Hacker%20Way https://twitter.com/gotocph https://www.facebook.com/GOTOConference http://gotocon.com
Clean Coders Hate What Happens to Your Code When You Use These Enterprise Programming Tricks
It is all to easy to dismiss problematic codebases on some nebulous idea of bad practice or bad programmers. Poor code, however, is rarely arbitrary and random in its structure or formulation. Systems of code, well or poorly structured, emerge from systems of practice, whether effective or ineffective. To improve code quality, it makes more sense to pick apart the specific practices and see their interplay — the cause — than to simply focus on the code itself — the effect. This talk looks at how a handful of coding habits, design practices and assumptions can systematically balloon code and compound its accidental complexity.
Scalability at YouTube
Shannon -jj Behrens, Mike Solomon This talk covers scalability at YouTube. It's given by one of the original engineers at YouTube, Mike Solomon. It's a rare glimpse into the heart of YouTube which is one of the largest websites in the world, and on
How brain science will change computing
Treo creator Jeff Hawkins urges us to take a new look at the brain -- to see it not as a fast processor, but as a memory system that stores and plays back experiences to help us predict, intelligently, what will happen next.
[JSConfUS 2013] Steven Wittens: Making WebGL Dance
Jean Yang on An Axiomatic Basis for Computer Programming
Meetup: http://www.meetup.com/papers-we-love/events/214400572/ Paper: http://www.cs.cmu.edu/~crary/819-f09/Hoare69.pdf Slides: https://speakerdeck.com/paperswelove/jean-yang-on-an-axiomatic-basis-for-computer-programming Audio: http://www.mixcloud.com/paperswelove/jean-yang-on-an-axiomatic-basis-for-computer-programming/ --------------------------------------------------------------------------------------------- Sponsored by The Ladders (@TheLaddersDev) --------------------------------------------------------------------------------------------- Description --------------- Our lives now run on software. Bugs are becoming not just annoyances for software developers, but sources of potentially catastrophic failures. A careless programmer mistake could leak our social security numbers or crash our cars. While testing provides some assurance, it is difficult to test all possibilities in complex systems--and practically impossible in concurrent systems. For the critical systems in our lives, we should demand mathematical guarantees that the software behaves the way the programmer expected. A single paper influenced much of the work towards providing these mathematical guarantees. C.A.R. Hoare’s seminal 1969 paper “An Axiomatic Basis for Computer Programming” introduces a method of reasoning about program correctness now known as Hoare logic. In this paper, Hoare provides a technique that 1) allows programmers to express program properties and 2) allows these properties to be automatically checked. These ideas have influenced decades of research in automated reasoning about software correctness. In this talk, I will describe the main ideas in Hoare logic, as well as the impact of these ideas. I will talk about my personal experience using Hoare logic to verify memory guarantees in an operating system. I will also discuss takeaway lessons for working programmers. Bio ---- Jean Yang (@jeanqasaur) is a final-year PhD student at MIT. For her PhD thesis she has created Jeeves, a programming language for automatically enforcing information flow policies for security and privacy. You may be more familiar with one of her other projects, Haskell Ryan Gosling.
Andrew T. Baker - Demystifying Docker - PyCon 2015
"Speaker: Andrew T. Baker Docker was one of last year’s most talked about open source projects - but what is it? And what does it mean for deploying applications? This talk will explain what Docker is and where it fits in with other deployment techniques. Attendees will learn the fundamentals of Docker, see some practical examples of how Docker is used, and consider if Docker could be a useful addition to their platform. Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Mozilla Raw WebGL
Google I/O 2013 - Design Decisions in AngularJS
26 years with Erlang or How I got my grey hairs
Joe Armstrong History of Erlang, right from the horse's mouth. http://www.meetup.com/ErlangChicago/events/124283112/ You are seeing it right! Joe Armstrong, the Father of Erlang will be here, in Chicago! In July! 2013! This is a fantastic opportunity to hang out with one of Computer Science's luminary thinkers and personalities. Joe will be speaking on "Sherlock's Last Case" - from a chapter of his recently released 2nd edition of Programming Erlang. If you're even remotely interest
Google I/O 2014 - Unlock the next era of UI development with Polymer
Speaker(s): Rob Dodson Description: Entering the multi-screen era means rethinking how we build our applications. Producing a few PSDs doesn't cut it anymore, we have to start seeing the things we design as components within larger systems. Join us to learn how to use Polymer to revolutionize your design process. With these new tools we can create the UIs of the future, and shorten the time between concept and reality. Watch all Google I/O 2014 videos at: g.co/io14videos
Why the world needs WikiLeaks
The controversial website WikiLeaks collects and posts highly classified documents and video. Founder Julian Assange, who's reportedly being sought for questioning by US authorities, talks to TED's Chris Anderson about how the site operates, what it has accomplished -- and what drives him. The interview includes graphic footage of a recent US airstrike in Baghdad.
Allison Kaptur - Bytes in the Machine: Inside the CPython interpreter - PyCon 2015
"Speaker: Allison Kaptur Have you ever wondered how the CPython interpreter works? Do you know where to find a 1,500 line switch statement in CPython? I'll talk about the structure of the interpreter that we all use every day by explaining how Ned Batchelder and I chased down a mysterious bug in Byterun, a Python interpreter written in Python. We'll also see visualizations of the VM as it executes your code. Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Genetic Programming in Clojure - Lee Spector
Genetic programming harnesses the mechanisms of natural evolution, including mutation, recombination, and natural selection, to automatically synthesize computer programs. It has been applied to a wide range of problems spanning several areas of science, engineering, and the arts, in many cases equaling or exceeding human performance. Genetic programming's roots are in Lisp, making Clojure a natural choice for modern genetic programming research and development. In this talk I will show how a simple genetic programming system can be written in about 100 lines of Clojure code, how a mature genetic programming system (PushGP) implemented in Clojure can improve the state of the art in automatic programming, and how genetic programming can be incorporated into an artificial life environment implemented in Clojure and Quil. About the speaker: Lee Spector is a Professor of Computer Science in the School of Cognitive Science at Hampshire College in Amherst, Massachusetts, and an adjunct professor of Computer Science at the University of Massachusetts, Amherst. His areas of teaching and research include genetic and evolutionary computation, quantum computation, and a variety of intersections between computer science, cognitive science, evolutionary biology, and the arts. He is the Editor-in-Chief of the journal Genetic Programming and Evolvable Machines (published by Springer) and a member of the editorial board of Evolutionary Computation (published by MIT Press). He is also a member of the SIGEVO executive committee and he was named a Fellow of the International Society for Genetic and Evolutionary Computation. More details: http://hampshire.edu/lspector Resume: http://hampshire.edu/lspector/spector-resume.pdf
Keith Salisbury - Building Multiplayer Games with Phoenix and Phaser (ElixirConfEU 2016)
Slides and more info: http://www.elixirconf.eu/elixirconf2016/keith-salisbury Phoenix and Phaser might sound like a cheesy pop band but get these two frameworks playing nice together and you're guaranteed a party. Both are blistering fast, and incredibly easy to use. Building multiplayer games has never been easier. Talk objectives This talk will take you on a step by step guide building yourself a game template, and then using that template to create several multiplayer games. We will introduce you to the joy of creating games using these two wonderful frameworks, and demonstrate some of the possibilities, as well as highlighting some of the challenges and common pitfalls to avoid when developing multiplayer games. Target audience Beginners and anyone interested in having fun with Phoenix channels. Keith is a programmer, sailor and kitesurfer in any order. He is passionate software development and particularly enjoying building fun social games. He is currently writing a book of the same title as this talk. Github: ktec Twitter: @ktec
Curtis Lassam - Hash Functions and You: Partners in Freedom - PyCon 2015
"Speaker: Curtis Lassam Our trusty friend, the hash function, is as crucial to programming as linked lists or recursion, but it doesn't always get the press that it deserves. We're going to talk about hash functions, some data structures involving hash functions, the stately bloom filter, and the security implications of password hashing. Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Guy Steele: Dan Friedman--Cool Ideas (Dan Friedman's 60th Birthday)
Guy Steele keynote address: Dan Friedman--Cool Ideas http://www.cs.indiana.edu/dfried_celebration.html Recorded 3:00 pm, Friday, December 3rd, 2004.
"Propositions as Types" by Philip Wadler
The principle of Propositions as Types links logic to computation. At first sight it appears to be a simple coincidence---almost a pun---but it turns out to be remarkably robust, inspiring the design of theorem provers and programming languages, and continuing to influence the forefronts of computing. Propositions as Types has many names and many origins, and is a notion with depth, breadth, and mystery. Learn why functional programming is (and is not) the universal programming language. Philip Wadler UNIVERSITY OF EDINBURGH @PhilipWadler Philip Wadler is Professor of Theoretical Computer Science at the University of Edinburgh. He is an ACM Fellow and a Fellow of the Royal Society of Edinburgh, past chair of ACM SIGPLAN, past holder of a Royal Society-Wolfson Research Merit Fellowship, and a winner of the POPL Most Influential Paper Award. Previously, he worked or studied at Stanford, Xerox Parc, CMU, Oxford, Chalmers, Glasgow, Bell Labs, and Avaya Labs, and visited as a guest professor in Copenhagen, Sydney, and Paris. He has an h-index of 60, with more than 18,000 citations to his work according to Google Scholar. He contributed to the designs of Haskell, Java, and XQuery, and is a co-author of Introduction to Functional Programming (Prentice Hall, 1988), XQuery from the Experts (Addison Wesley, 2004) and Generics and Collections in Java (O'Reilly, 2006). He has delivered invited talks in locations ranging from Aizu to Zurich.
"React: RESTful UI Rendering" by Pete Hunt
React is a new a conceptual model for rendering user interfaces in a functional style. In this talk I'll look at how both the user-facing and implementation specifics resemble RESTful architectures and some interesting patterns and properties that fall out of this. by Pete Hunt (@floydophone) Pete works on Facebook's React team and manages the Instagram.com web team.
It's not what you read, it's what you ignore
As developers, we are asked to absorb even more information than ever before. More APIs, more documentation, more patterns, more layers of abstraction. Now Twitter and Facebook compete with Email and Texts for our attention, keeping us up-to-date on our friends' dietary details and movie attendance second-by-second. Does all this information take a toll on your psyche or sharpen the saw? Is it a matter of finding the right tools and filters to capture what you need, or do you just need to unplug? Is ZEB (zero email bounce) a myth or are there substantive techniques for prioritizing your live as a developer? Join Scott Hanselman as we explore this topic...perhaps we'll crowd-source the answers!
Teaching creative computer science
This talk was given at a local TEDx event, produced independently of the TED Conferences. Simon Peyton Jones wants children not just to consume technology, but to be creative with it. What does that mean for teaching computer science in schools, and why is the rest of the world watching England? Simon Peyton Jones is a principal researcher at Microsoft Research in Cambridge. His research focus is in programming language design and implementation, and the purely-functional language Haskell in particular. He is a founder member and current chair of the Computing at School working group, which has played a central role in the recent reform of the school Computing curriculum. At TEDxExeter 2014 our speakers and performers connected us with other worlds. Our talks exposed corruption in big business, shared effective approaches to tackling social inequality and gave a voice to those whose human rights are under threat. We explored the impact of fast changing technologies on all our lives. We journeyed through fire and forest to frozen landscapes. We were challenged to consider worlds of extremes, cutting edge controversies and risky opportunities. https://twitter.com/simonpj0 Video Production Chromatrope (http://chromatrope.co.uk/) Production Manager Andy Robertson (http://www.youtube.com/familygamertv) About TEDx, x = independently organized event In the spirit of ideas worth spreading, TEDx is a program of local, self-organized events that bring people together to share a TED-like experience. At a TEDx event, TEDTalks video and live speakers combine to spark deep discussion and connection in a small group. These local, self-organized events are branded TEDx, where x = independently organized TED event. The TED Conference provides general guidance for the TEDx program, but individual TEDx events are self-organized.* (*Subject to certain rules and regulations)
Why Google Glass?
It's not a demo, more of a philosophical argument: Why did Sergey Brin and his team at Google want to build an eye-mounted camera/computer, codenamed Glass? Onstage at TED2013, Brin calls for a new way of seeing our relationship with our mobile computers -- not hunched over a screen but meeting the world heads-up.
Principles of Lighting and Rendering with John Carmack at QuakeCon 2013
One of the best, if not the best Keynote of his. I only wonder, how John did not get more time. Come on, he is so important and only 1 hour?
code::dive conference 2014 - Scott Meyers: Support for Embedded Programming in C++11 and C++14
code::dive conference 2014 - Nokia Wrocław http://codedive.pl/
AWS Innovation at Scale
This session, led by James Hamilton, VP and Distinguished Engineer, gives an insider view of some the innovations that help make the AWS cloud unique. He will show examples of AWS networking innovations from the interregional network backbone, through custom routers and networking protocol stack, all the way down to individual servers. He will show examples from AWS server hardware, storage, and power distribution and then, up the stack, in high scale streaming data processing. James will also dive into fundamental database work AWS is delivering to open up scaling and performance limits, reduce costs, and eliminate much of the administrative burden of managing databases. Join this session and walk away with a deeper understanding of the underlying innovations powering the cloud.
LoneStarRuby 2015 - Building a binary protocol client in Ruby: A magical journey!
By Trevor Rosen and egypt Sometimes we can forget that there's more under the (networking) sun than HTTP. Rapid7's Metasploit team has been working for awhile on a new, pure-Ruby library for Microsoft's SMB protocol. Doing work like this means analyzing wire traffic, working with binary structs, and wrapping everything up into a nice, clean set of abstractions. We'd like to share the developer workflows and lessons learned. If you've ever wondered how to set about building a library for a binary protocol, how to reverse-engineer the byte-by-byte traffic on a network, or thought it would be cool to understand Ruby's networking capabilities from the ground up, this talk is for you! Help us caption & translate this video! http://amara.org/v/HBVG/
(fifth RacketCon): Alexis King — Generic Collections: One Interface to Rule Them All
Racket encourages a functional style, but aside from immutable pairs, the collections library remains unsuitable for rich functional programming with a complement of functional data structures. Racket programmers may reach for linked lists when better structures would do to avoid the list-ref/vector-ref/stream-ref function zoo. This talk discusses the implementation of a generic collections system that encourages immutability by default, provides a more consistent and comprehensive interface across all data structures, and provides that interface in a way that can be leveraged by new, user-defined structures to feel as integrated with the language as Racket’s built-ins. Alexis King works as a full-stack web developer at Philosophie in Los Angeles building rich web applications with Ruby on Rails and Angular. When not tinkering with different models to create expressive RESTful APIs, she is enthusiastic about finding ways to build programming interfaces that are expressive and easy to use. In Racket, that means figuring out how to build flexible DSLs and extensible language constructs that integrate well into the rest of the Racket ecosystem without sacrificing elegance or hygiene.
James Powell - Python and Johnny Cash
PyData London 2016 I was given this title by the Executive Director of NumFOCUS as punishment for being late in putting together a proposal. This talk will be a huge stretch to link Python to Johnny Cash. I suppose this means I'll have to wear all black. I'll probably show off some nifty (C)Python hacks, like adding AST-literals or resurrecting the print statement or implementing lambda-fusion.
Chicago Boss: A Web Framework Built for Comfort (and Speed) - Evan Miller
Erlang Factory SF Bay Area 2013 More info and slides on the website: http://www.erlang-factory.com/conference/SFBay2013/talks We all know that Erlang is great for building complicated distributed systems, but did you know that building a website in Erlang is as easy as using Ruby on Rails? In this talk I'll introduce you to Chicago Boss, the web framework that takes care of all the hard parts of Erlang/OTP for you, letting the developer focus on building a great website. I'll explain why Erlang is an excellent choice for delivering web content, give a high-level overview of the Chicago Boss architecture, and explicate the philosophy behind some of CB's controversial design decisions. In the process we'll cover CB's high-performance template system, its custom compiler chain and language-integrated query syntax, its unique approaches to e-mail and i18n, and everything in between. Some practical code examples will be included at the end. All levels of expertise are welcome.
DjangoCon EU 2013: Steven Holmes - Does your stuff scale?
Videos from DjangoCon Europe 2013 are kindly provided by Heroku, a cloud application platform -- a new way of building and deploying web apps: http://heroku.com/
Career Advice for Programmers
Anyone ever give you advice on how to remain a programmer? To avoid being "promoted" into positions away from technology and code? Anyone ever tell you at school or university that you needed social skills to be a good developer? Did you know, without having had half a dozen different jobs, that all development roles are not created equal? Is it true that moving jobs a lot is a Bad Thing? In this session I'm going to share some lessons I learnt the hard way while managing my career as a Java developer. I'm going to tell you secrets that others don't want to share. And I'll give you tools for working out what your next steps are. If nothing else, you'll get to laugh at the (many) mistakes I've made in my search for The Perfect Job.
Brian J Brennan: Being Human [JSConf2014]
We spend so much time building things that we sometimes forget that we're building for, and with, other complex human beings. Remembering that we are people first is the first step to making a positive shift in the way we treat each other. http://2014.jsconf.us/
"The Sociology of Programming Languages" by Leo Meyerovich
David Beazley - Python Concurrency From the Ground Up: LIVE! - PyCon 2015
"Speaker: David Beazley There are currently three popular approaches to Python concurrency: threads, event loops, and coroutines. Each is shrouded by various degrees of mystery and peril. In this talk, all three approaches will be deconstructed and explained in a epic ground-up live coding battle. Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Om Next - David Nolen
ClojureScript: Lisp's Revenge • David Nolen
Dan Doel - Introduction to Low Level Haskell Optimization
Dan Doel's talk at the Boston Haskell Meetup, Sept 17, 2014 Slides: https://drive.google.com/file/d/0B8Kkr1O1jFwcRmhxbzBMR1Ntb3c/edit?usp=sharing
Craig Kerstiens: Postgres Performance for Humans - PyCon 2014
Speaker: Craig Kerstiens To many developers the database is a black box. You expect to be able to put data into your database, have it to stay there, and get it out when you query it... hopefully in a performant manner. When its not performant enough the two options are usually add some indexes or throw some hardware at it. We'll walk through a bit of a clearer guide of how you can understand and manage DB performance. Slides can be found at: https://speakerdeck.com/pycon2014 and https://github.com/PyCon/2014-slides
Scala Monads: Declutter Your Code With Monadic Design
In this video tutorial, Dan Rosen will show you how to use Scala's capacity for monadic design to eliminate repetitive boilerplate in your code. You'll learn to recognize places where the perpetual clutter of null checks, try-catch blocks and more can be hidden within a monad, to make your code's logic stand out clearly. ** Head to http://marakana.com for more open source educational resources
Rethinking Computer Science Education
Alan Kay talks about alternative approaches to teach Computer Science in schools.
How the PyPy JIT works
Benjamin Peterson The Python community is abuzz about the major speed gains PyPy can offer pure Python code. But how does PyPy JIT actually work? This talk will discuss how the PyPy JIT is implemented. It will include descriptions of the tracing, opt
Power of Simplicity
One of my all time favorite talks of Alan Kay's, given in 2015. Not my own video, though it hasn't been on YouTube before. Original location here: http://global.sap.com/campaign/na/usa/CRM-XU15-INT-STILP/index.html
Martin Rehfeld - How To Ship New Code Without Taking Your System Down - Berlin Erlang Factory Lite
Deployment Options: How To Ship New Code Without Taking Your System Down Erlang is quite famous for long-running interruption-free installations. But how is this achieved in practice while still evolving the software? We will look at different deployment options, from simple to advanced: 1. Deployment by restart 2. Hot code reloading 3. Release handling See hot code reloading in action and learn how to avoid common traps & pitfalls. Talk objectives: By the end of this talk you shall be able to decide: Which strategy is right for me? What do I have to consider? Target audience: General familiarity with Erlang is assumed.
Syntaxation • Douglas Crockford
Check out our upcoming conferences at http://gotocon.com Subscribe to GOTO Conference's YouTube Channel at http://www.youtube.com/user/GOTOConferences?sub_confirmation=1 Douglas Crockford - JSON Creator & Yahoo! JS Architect ABSTRACT Much of programming language design is dictated by fashion. As a consequence, opinions about programming languages tend to be strong, shallow, and deeply emotional. The best languages are brilliant and sadly unfashionable. But we love our stylish, over-rated syntax, and this talk presents an amazing parsing technique that helps achieve it. https://twitter.com/gotocon https://www.facebook.com/GOTOConference http://gotocon.com
Marcus Lagergren: The Java Virtual Machine is Over - The Polyglot VM is here
Ever since Java's inception, in 1995, people have been compiling languages that aren't Java to bytecode and deploying them on the JVM. Lately, we are seeing an explosion in JVM languages. This is partly, but not only, because of Java 7, the first JVM to ship with invokedynamic, which is a quantum leap in polyglot runtime implementation. This session explains why emerging language implementations are becoming more common and more feasible to implement on the JVM with satisfactory performance. It tells you how we got there and walks through the technology already in place (such as invokedynamic) and that which is in progress. The future for the JVM is bright indeed. Filmed at JAX London 2013.
Transforming Code into Beautiful, Idiomatic Python
Raymond Hettinger Learn to take better advantage of Python's best features and improve existing code through a series of code transformations, "When you see this, do that instead."
Understanding the Python GIL
Dave Beazley's presentation from PyCon'2010 in Atlanta Georgia. This is a mirror of the original presentation hosted at http://blip.tv/pycon-us-videos-2009-2010-2011/pycon-2010-understanding-the-python-gil-82-3273690.
Andy Keep - Writing a Nanopass Compiler
Contemporary compilers are among the most complex of software systems, typically being required to handle sophisticated high-level source languages, generate efficient code for multiple hardware architectures and operating systems, and support source-level debuggers, profilers, and other program development tools. Nanopass frameworks are designed to help manage this complexity. A nanopass compiler is comprised of many single-task passes with formally defined intermediate languages. The nanopass compiler technique evolved from a methodology for teaching a compiler course at Indiana University, into a full-fledged framework, capable of implementing a replacement for the Chez Scheme compiler that runs on par with the original compiler. This talk will discuss the idea of a nanopass compiler and the implementation of a simple language using the framework in Chez Scheme, along with the challenges and opportunities of using these techniques in Clojure. Andy is a postdoc at the University of Utah, currently working on malware detection in Android Apps, using both Scala and miniKanren to write abstract analyzers in Matt Might's lab. Andy completed his Ph.D. at Indiana University, defending his dissertation, "A Nanopass Framework for Commercial Compiler Development", in December 2012 and will be presenting a paper related to this work at this year's International Conference on Functional Programming. This project focused on replacing Chez Scheme's compiler with a nanopass compiler, along with his adviser R. Kent Dybvig. Before returning to graduate school in 2007, Andy worked in industry as a web developer, first for the consulting firms Razorfish and Gotham Broadband, along with some independent consulting work for Viacom, and later worked full time at Teach For America, maintaining both front-end and back-end web applications.
Scala Versus Java
Java is no longer alone on the JVM. It now has to share space with its younger siblings JRuby, Jython, Groovy, Clojure, Scala and many others. Each new language has its own set of advantages and disadvantages compared to Java, and its own niche in which it performs best, but Scala in particular is gaining momentum. In this presentation to San Francisco Java User Group on January 18, 2012, Marakana's own Dan Rosen introduces Scala to Java developers and shows off some of its expressive power -- higher-order functions, type inference, and pattern matching -- by building a simple web service. You'll never look at Java the same way. Slides from this presentation available here http://bit.ly/ztgVxa
Inventing on Principle
Bret Victor invents tools that enable people to understand and create. He has designed experimental UI concepts at Apple, interactive data graphics for Al Gore, and musical instruments at Alesis.
Stuart Williams This tutorial is for software developers who've been using Python with success for a while but are looking for a deeper understanding of the language. It demystifies a number of language features that are often misunderstood.
Ryan Kelly - PyPy.js: What? How? Why? - PyCon 2015
(fifth RacketCon): Jack Firth — Generic Syntax Expanders and Extensible Macros
Racket’s powerful syntax system allows things like pattern matching not only to be implemented as macros, but to be user-extensible as well. Match expanders, for example, allows users to extend Racket’s pattern matcher with arbitrary new patterns. This talk discusses a generalized approach to match-expanders and its uses in defining macros with embedded user-extensible syntax, and shows an application of this approach to Racket’s command line parsing forms. Jack Firth works at Mindjet in San Francisco as a developer of enterprise web applications and as a mentor to his colleagues on functional programming, particularly its applications to a Node / Angular stack. He has been a professional software engineer for a year and a half, but first began programming nine years ago. He attended college for mechanical engineering at a young age. His programming-related interests outside work include multi-language architectures, CI, testing, obscure languages, static verification, and type systems. He also used to be a hobbyist game developer, and still is once in a blue moon.
Google I/O 2013 - Advanced Go Concurrency Patterns
Sameer Ajmani Concurrency is the key to designing high performance network services. This talk expands on last year's popular Go Concurrency Patterns talk to dive deeper into Go's concurrency primitives, and see how tricky concurrency problems can be solved gracefully with simple Go code. For all I/O 2013 sessions, go to https://developers.google.com/live
"Uncle" Bob Martin
Software luminary “Uncle Bob” Martin spoke to members of the Yale and New Haven communities at Yale School of Management. Martin had been a professional programmer since 1970; since then he has become a prolific author and leader in the industry. Dan Bernier of New Haven’s Continuity Control and nhv.io, introduced Bob, noting that in the “weird and messy business” of software development, Uncle Bob is there to look out for and guide developers. Martin emphasized the importance of writing clean, efficient, well-written code—sage advise for aspiring programmers and tech-entrepreneurs. Interest in development and programming is on the rise at SOM as student-entrepreneurs explore tech-based startup ideas. Classes like CS112, co-developed by SOM’s Program on Entrepreneurship and the Department of Computer Science, give students curricular opportunities to develop their skills. Student-entrepreneurs are likewise embracing extracurricular opportunities around programming. HackYaleSOM, SOM’s student programming organization, continues to gain members while interest in HackYale, an undergraduate organization offering programming workshops, has reached record highs: one thousand candidates applied for only 80 seats in their “Introduction to Web Development” workshop.
Machine Learning Live - Mike Anderson
This presentation will introduce a new start-up focused on machine learning that is using Clojure. We will discuss the technology and architecture it has developed for real-time machine learning and pattern recognition, and how Clojure provides a unique set of advantages. There will be a live coding demonstration of interactively applying machine learning to a simple task and visualization of the results.
Fun with the Lambda Calculus • Corey Haines
This presentation was recorded at GOTO Chicago 2015 http://gotochgo.com Corey Haines - Author, Speaker, Teacher & all around Groovy Guy ABSTRACT You've probably heard about the lambda calculus, building up our computing structures from just the treasured lambda. But how much have you played with it? In this talk, armed only with Vim and the CLI, we'll explore [...] Download slides and read the full abstract here: http://gotocon.com/chicago-2015/presentation/Fun%20with%20the%20lambda%20calculus https://twitter.com/gotochgo https://www.facebook.com/GOTOConference http://gotocon.com
Jennifer De Walt: How I learned to Code by Making 180 websites in 180 days | JSConf.ar 2014
With no real coding experience, I decided to sit down and teach myself to code by making one website a day, every day, for 180 days. In this session, I'll cover what inspired me to take the path of self directed learning and what challenges I faced along the way. The first websites I made were simple and only used a tiny bit of html and css. By the end I was making dynamic, interactive apps. In this talk I'll present a selection of some of my favorite websites from the project which include games, toys, physics simulations, data visualizations and real time communication apps. https://www.jsconfar.com/
Rethinking Design, Risk, and Software
Our increasingly complex needs have led us to build increasing complex software. We’ve done this in an incremental fashion, building code on top of code. We write understandable snippets of code built on programming languages we know well and then bundle them into program structures to perform complex tasks. This incremental process may seem to have low risk at the snippet level, but it leads to program structures that can be hundreds of millions of lines of code that is intractable to change, redesign, and understanding, nor in the end is it easy to design. It also leads to code with potentially unwanted emergent properties. Today, we know how to create programs that can create programming languages. So why not write software that closely follows the problem, without a programming language, then let other programs create the programming language to support it? If we apply this rethinking to the design process, both problems and solutions can be thought of in terms of relational str
This talk is about how software, particularly open-source software, is not only eating the world but eating capitalism itself - from the inside out. Last summer I read Paul Mason's Postcapitalism and thereafter Rifkin's The Zero Marginal Cost Society. As I did this, and made notes, I came to see that our own open sourced products, such as Mini-Mesos and our ElasticSearch Framework, were threatening to disrupt our commercial competitors. After thinking more about this, it's very obvious to see that open source software, and for example 3-D printing, is not only disrupting how we build things but is also undermining the core relationships of capitalism. If the marginal cost of a unit is free and so is its price, then there cannot be any profit. This one relationship undermines the very foundation of capitalism - something that Marx predicted. This talk will look at capitalism, post capitalism, and as a case study will look at our ElasticSearch framework for Mesos. I will give insights into how companies can still stay relevant even when software is free - and I will do this by looking at how windmills utterly disrupted landowners in 11th century Yorkshire.
On being wrong
Most of us will do anything to avoid being wrong. But what if we're wrong about that? "Wrongologist" Kathryn Schulz makes a compelling case for not just admitting but embracing our fallibility.
CppCon 2014: Andrei Alexandrescu "Optimization Tips - Mo' Hustle Mo' Problems"
http://www.cppcon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- Reasonably-written C++ code will be naturally fast. This is to C++'s excellent low-penalty abstractions and a memory model close to the machine. However, a large category of applications have no boundaries on desired speed, meaning there's no point of diminishing returns in making code faster. Better speed means less power consumed for the same work, more workload with the same data center expense, better features for the end user, more features for machine learning, better analytics, and more. Optimizing has always been an art, and in particular optimizing C++ on contemporary hardware has become a task of formidable complexity. This is because modern hardware has a few peculiarities about it that are not sufficiently understood and explored. This talk discusses a few such effects, and guides the attendee on how to navigate design and implementation options in search for better performance. -- Andrei Alexandrescu is a researcher, software engineer, and author. He wrote three best-selling books on programming (Modern C++ Design, C++ Coding Standards, and The D Programming Language) and numerous articles and papers on wide-ranging topics from programming to language design to Machine Learning to Natural Language Processing. Andrei holds a PhD in Computer Science from the University of Washington and a BSc in Electrical Engineering from University "Politehnica" Bucharest. He works as a Research Scientist for Facebook. Website: http://erdani.com Twitter handle: @incomputable -- Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Intel OpenCL SDK Vectorizer
In this talk, we will present our OpenCL SDK and its core technology -- the vectorizer compiler. We plan to present an overview of our vectorizer and discuss our experience with the LLVM compiler toolkit over the last few years. We will discuss some of our design decisions and our and plans for future features (future instruction sets, vector select, predicated instructions, etc).
"I See What You Mean" by Peter Alvaro
I love query languages for many reasons, but mostly because of their semantics. Wait, come back! In contrast to most systems programming languages (whose semantics can be quite esoteric), the semantics of a query (given some inputs) are precisely its outcome -- rows in tables. Hence when we write a query, we directly engage with its semantics: we simply say what we mean. This makes it easy and natural to reason about whether our queries are correct: that is, whether they mean what we intended them to mean. Query languages have traditionally been applied to a relatively narrow domains: historically, data at rest in data stores; more recently, data in motion through continuous, "streaming" query frameworks. Why stop here? Could query languages do for a notoriously complex domain such as distributed systems programming what they have done so successfully for data management? How would they need to evolve to become expressive enough to capture the programs that we need to write, while retaining a simple enough semantics to allow mere mortals to reason about their correctness? I will attempt to answer these questions (and raise many others) by describing a query language for distributed programming called Dedalus. Like traditional query languages, Dedalus abstracts away many of the details we typically associate with programming, making data and time first-class citizens and relegating computation to a subordinate role, characterizing how data is allowed to change as it moves through space and time. As we will see, this shift allows programmers to directly reason about distributed correctness properties such as consistency and fault-tolerance, and lays the foundations for powerful program analysis and repair tools (such as Blazes and LDFI), as well as successive generations of data-centric programming languages (including Bloom, Edelweiss and Eve). Peter Alvaro UNIVERSITY OF CALIFORNIA SANTA CRUZ @palvaro Peter Alvaro is an Assistant Professor of Computer Science at the University of California Santa Cruz. His research focuses on using data-centric languages and analysis techniques to build and reason about data-intensive distributed systems, in order to make them scalable, predictable and robust to the failures and nondeterminism endemic to large-scale distribution. Peter is the creator of the Dedalus language and co-creator of the Bloom language. While pursuing his PhD at while UC Berkeley, Peter co-developed and taught Programming the Cloud, an undergraduate course that explored distributed systems concepts through the lens of software development. Prior to attending Berkeley, Peter worked as a Senior Software Engineer in the data analytics team at Ask.com. Peter's principal research interests are databases, distributed systems and programming languages.
: Parallax Performance
The most tactile feel your users have of your site's performance is how it scrolls. A site that can't scroll smoothly is a silent but deadly killer of user of user engagement. We'll diagnose several popular sites and visualize their problems, fix their implementations, and unveil a brand new technique for parallax that makes sure that you can enhance the user experience with scroll-driven effects but do it at 60fps.
Paul Irish, "Delivering the goods" - Fluent 2014 Keynote
Fluent 2014, "Keynote With Paul Irish". About Paul Irish (Google): Paul Irish is a front-end developer who loves the web. He is on Google Chrome's Developer Relations team as well as jQuery's. He develops the HTML5 Boilerplate, the HTML5/CSS3 feature detection library Modernizr, HTML5 Please, CSS3 Please, and other bits and bobs of open source code. Don't miss an upload! Subscribe! http://goo.gl/szEauh Stay Connected to O'Reilly Media by Email - http://goo.gl/YZSWbO Follow O'Reilly Media: http://plus.google.com/+oreillymedia https://www.facebook.com/OReilly https://twitter.com/OReillyMedia
The Language of the System - Rich Hickey
Clojure Data Science - Edmund Jackson
Data science / big data exists at the overlap of traditional analytics and large scale computation. As such, neither the traditional tools of analytics (R, Mathematica, Matlab) nor mainstreams languages (Java, C++, C#) supply its requirements well as they cannot simultaneously provide the mathematical abstractions and real-word platform power that are required. Clojure is privileged in that it has the potential to provide just exactly that. This talk will explore why this is the case, the tools that are available and the challenges that need be overcome for Clojure to realise this potential.
David Beazley: Discovering Python - PyCon 2014
Speaker: David Beazley So, what happens when you lock a Python programmer in a secret vault containing 1.5 TBytes of C++ source code and no internet connection? Find out as I describe how I used Python as a secret weapon of "discovery" in an epic legal battle. Slides can be found at: https://speakerdeck.com/pycon2014 and https://github.com/PyCon/2014-slides
CSSConf Oakland 2014 | Mark Otto and Connor Sears: Stuff About Cascading Style Sheets
MARK OTTO Currently designing at GitHub. Creator of Bootstrap. Previously at Twitter. Huge nerd. http://markdotto.com/ https://twitter.com/mdo CONNOR SEARS Co-creator of Ratchet. Currently at GitHub helping create a better way to design, build, and ship software. Previously at Pinterest, Twitter, and ZURB. http://connor.town/ https://twitter.com/connors
Learn Python Through Public Data Hacking
David Beazley What's more fun than learning Python? Learning Python by hacking on public data! In this tutorial, you'll learn Python basics by reading files, scraping the web, building data structures, and analyzing real world data. By the end, you w
The Many Meanings of Event-Driven Architecture
Towards the end of last year I attended a workshop with my colleagues in ThoughtWorks to discuss the nature of “event-driven” applications. Over the last few years we've been building lots of systems that make a lot of use of events, and they've been often praised, and often damned. Our North American office organized a summit, and ThoughtWorks senior developers from all over the world showed up to share ideas. The biggest outcome of the summit was recognizing that when people talk about “events”, they actually mean some quite different things. So we spent a lot of time trying to tease out what some useful patterns might be. This note is a brief summary of the main ones we identified.
LoneStarRuby 2015 Phoenix - Productive. Reliable. Fast. by Chris McCord
Phoenix is an Elixir web framework for building productive, reliable applications with the performance to take on the modern computing world. Together, we’ll review what makes Phoenix great and how it uses Elixir to optimize code for performance – without sacrificing programmer productivity. Along the way, we’ll see neat features like live-reload and generators and how Phoenix’s realtime layer takes on the modern web. Help us caption & translate this video! http://amara.org/v/HBVF/
Tim Ewald - Clojure: Programming with Hand Tools
For most of human history, furniture was built by hand using a small set of simple tools. This approach connects you in a profoundly direct way to the work, your effort to the result. This changed with the rise of machine tools, which made production more efficient but also altered what's made and how we think about making it in in a profound way. This talk explores the effects of automation on our work, which is as relevant to software as it is to furniture, especially now that once again, with Clojure, we are building things using a small set of simple tools. Tim Ewald designs and builds software systems. After 20 years using object oriented languages, he embraces Clojure because it provides the closes connection to the work and most directly expresses his intent. Tim works on the Datomic team at Cognitect, where he is a Vice President.
David Nolen: Immutability: Putting The Dream Machine To Work [JSConf2014]
Write code faster: expert-level vim
This talk will make you much faster with vim. Most people that start learning vim get stuck in a rut right around low-intermediate. They can get everything done, but not very quickly. Lots of people never get any faster from here. This talk is targeted at users of vim aren't satisfied with where they are, and want to learn to write and edit code at breakneck speed. We'll focus on the knowledge and philosophy necessary to keep making huge leaps in efficiency and to approach expert status. Expect a talk jammed full of specific tips and general advice that you can apply immediately.
Convex Optimization in Julia
Presented by Madeleine Udell at JuliaCon 2014. Link to slides: http://goo.gl/Nfy14D Julia is a high-level, high-performance dynamic programming language for technical computing, with syntax that is familiar to users of other technical computing environments. It provides a sophisticated compiler, distributed parallel execution, numerical accuracy, and an extensive mathematical function library. The library, largely written in Julia itself, also integrates mature, best-of-breed C and Fortran libraries for linear algebra, random number generation, signal processing, and string processing. In addition, the Julia developer community is contributing a number of external packages through Julia's built-in package manager at a rapid pace.
Lambda Calculus Then and Now
Talk by ACM A.M. Turing Laureate Dana S. Scott during the ACM A.M. Turing Centenary Celebration, June, 2012. Abstract: A very fast development in the early 1930s, following Hilbert's codification of Mathematical Logic, led to the Incompleteness Theorems, Computable Functions, Undecidability Theorems, and the general formulation of recursive Function Theory. The so-called Lambda Calculus played a key role. The history of these developments will be traced, and the much later place of Lambda Calculus in Mathematics and Programming-Language Theory will be outlined.
Ruby Midwest 2011 Confident Code by Avdi Grimm
Are your methods timid? Do they constantly second-guess themselves, checking for nil values, errors, and unexpected input? Even the cleanest Ruby codebases can become littered over time with nil checks, error handling, and other interruptions which steal attention away from the essential purpose of the code. This talk will discuss strategies for writing your Ruby classes and methods in a confident, straightforward style; without sacrificing functionality or robustness. In the process, we'll cover concepts and techniques points including: The narrative style of method construction The four parts of a method Three strategies for dealing with uncertain input Massaging input with coercion and the Decorator pattern Lightweight preconditions Exterminating nils from your code The chaining and iterative styles of method construction Eliminating conditionals with the Special Case and Null Object patterns Isolating errors with the Bouncer and Checked Method patterns
Apple iPad 2 Keynote
http://bit.ly/gAAXPd This is the Apple Special Event 2011 which took place on 2nd March 2011 The iPad 2 is amazing! http://equimedia.blogspot.com/
The Scribe's Oath
We are the modern day scribes. Nothing happens in our society without us. But so far, we are unorganized, undisciplined, and we have no unifying ethics or standards. Society is becoming aware of us. Software developers have become both villains and heroes in our culture. More importantly, our society depends critically upon us. What oath, if any, should we swear? How would we enforce it?
Ember 2.0 - Erik Bryn
Erik Bryn (@ebryn), our friendly neighborhood Ember core team member, spoke about the plans for Ember 2.0 and how we can start preparing our apps for Ember 2.0 today. Erik is also going to be providing Ember 2.0 training classes in several cities this summer. You can preregister for them at: http://www.prototypal.io
What we're learning from online education
Daphne Koller is enticing top universities to put their most intriguing courses online for free -- not just as a service, but as a way to research how people learn. With Coursera (cofounded by Andrew Ng), each keystroke, quiz, peer-to-peer discussion and self-graded assignment builds an unprecedented pool of data on how knowledge is processed.
Simplifying Scala Collections — Bill Venners
The Scala standard library includes a large set of collections that covers a wide variety of use cases. For example, it offers both mutable and immutable collections, sequential and parallel collections, strict and lazy collections, and many combinations thereof. Although the standard collections library is widely used and works quite well today, this talk asks the question: how could the standard collections library be made better? We will look at various directions the Scala library could potentially evolve in the future, and discuss design trade-offs and migration strategies.
Stupid Gopher Tricks
They say you can't teach an old dog new tricks, but what about a gopher? In this talk we'll investigate a bunch of odd corners of the language, libraries, and tools that even seasoned Go programmers might not know.
Steve Jobs' 2005 Stanford Commencement Address
Drawing from some of the most pivotal points in his life, Steve Jobs, chief executive officer and co-founder of Apple Computer and of Pixar Animation Studios, urged graduates to pursue their dreams and see the opportunities in life's setbacks.
8 Secrets Of Success
Why do people succeed? Is it because they're smart? Or are they just lucky? Neither. Analyst Richard St. John condenses years of interviews into an unmissable 3-minute slideshow on the real secrets of success.
John Papa - 10 AngularJS Patterns - Code on the Beach 2014
Learn from John Papa's talk "10 AngularJS Patterns" from Code on the Beach 2014 at One Ocean Resort & Spa, Atlantic Beach, Florida. Sunday, August 10, 2014. www.codeonthebeach.com Abstract: "Once you get beyond the AngularJS basics there are many decisions to be made on how to build robust and maintainable apps. Come learn how to build AngularJS apps that manage multiple screens, structure your application code, maintain clean code with popular patterns, implement CRUD, perform robust HTML validation, use local storage, pass unit tests, and use a automated build tasks. This session explores solutions to several of the common challenges that AngularJS developers face while building business applications."
CSS Levels Up
CSS2, CSS3, CSS…4? This talk will explore a little bit of CSS past and present, disambiguate some version terminology (levels? modules?), and then dive into potential CSS future. We’ll examine what the Level 4 specifications bring to the table and what those new features could mean for the future of web development. Selectors, media queries, backgrounds, images, and text all have fresh recommendations to improve the web ecosystem. We’ll explore a little of each so you can be thinking ahead. The current state of polyfills and shims will be discussed so that the brave can forge ahead. We will also touch upon how a specification eventually becomes a feature so that you can understand the development of CSS, as well as where to go to participate in the discussions shaping the web of the future.
Compilers are caught in a tug-of-war between increasingly exotic architectures and instruction set extensions on one hand, and our desire for advanced programming languages and PL features on the other. A multi-language, multi-target compiler infrastructure such as LLVM ameliorates the situation somewhat, but engineering fast, effective and correct optimizations for LLVM is challenging. Even after a decade of intense development, there is a long tail of unimplemented optimizations. University of Utah Associate Professor John Regehr presents Souper, a superoptimizer that gives us a look at some of the optimizations that are missing from LLVM while also avoiding the bugs that are often found in hand-written optimization passes. Souper works by turning LLVM code into queries for an automated theorem prover. When Souper is run on LLVM itself, it identifies thousands of uncaught optimizations and also ranks them according to the likely improvement in code size or code speed that would result from implementing each one. John Regehr, Associate Professor, School of Computing, University of Utah 12/2/2014 https://www.cs.washington.edu/htbin-post/mvis/mvis?ID=2643 http://uwtv.org
PTX Back-End: GPU Programming With LLVM
In this talk, the PTX back-end for LLVM will be discussed, including its' past, present, and future. The current status of the back-end will be explored, with an emphasis on the portions of the LLVM IR instruction set and PTX intrinsics that are currently supported during code generation. This talk will also highlight the difficulties and issues that have been discovered while writing an LLVM back-end for a virtual ISA such as PTX, such as infinite register files. Through-out the talk, examples will be provided to highlight key features of the back-end and show preliminary performance data. In addition to back-end details, this talk will also highlight the use of Clang as a front-end for generating PTX code for NVIDIA GPUs. Through the use of Clang and the CUDA Driver API, GPGPU programs can be developed that harness the optimization power of the LLVM compiler infrastructure. Finally, the talk will conclude with an exploration of the open issues that remain in the backend, and a discussion on how the back-end can be used within larger GPGPU compiler projects.
Effective Java - Still Effective After All These Years
Joshua Bloch serves up a few Java Puzzlers as an appetizer before and as dessert after the main course on Effective Java. Organized By: Silicon Valley Web JUG - Van Riper and Kevin Nilson Hosted and Sponsored By: Google Video By: Marakana Event: http://www.meetup.com/sv-web-jug/calendar/10878461/ Slides: http://files.meetup.com/1381525/still-effective.ppt.pdf
Ruby Manor 3 - Programming with Nothing by Tom Stuart
All video production was done by or for Ruby Manor, Confreaks did not record this event, we are publishing it for community access. For more information about the event visit their web-site: http://rubymanor.org , or follow them on twitter @rubymanor. Help us caption & translate this video! http://amara.org/v/FGf7/
The Clang AST - a Tutorial
If you always wanted to know more about about Clang's AST , for example because you want to implement an awesome tool [2, 3] based on Clang, or simply because you want to start contributing, this talk is for you. Make sure to watch in HD to be able to read the font in the terminal! The semantic code completion in the vim session is powered by YCM , and the quick formatting is done by clang-format .  http://clang.llvm.org/docs/IntroductionToTheClangAST.html  http://clang.llvm.org/docs/Tooling.html  http://clang.llvm.org/docs/LibTooling.html  https://github.com/Valloric/YouCompleteMe  http://clang.llvm.org/docs/ClangFormat.html From the LLVM Euro Conference 2013: http://llvm.org/devmtg/2013-04/
Thomas Ballinger - Terminal whispering - PyCon 2015
"Speaker: Thomas Ballinger Have you ever wanted to add a status bar to your command line program? Or maybe color the output a bit? Or do you want to write a fullscreen terminal application like ls, top, vim, or emacs? Then you need to speak a bit of terminal! This talk describes how to talk to your terminal from scratch and goes on to show why Python libraries Blessings and Urwid are so awesome. Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Brett Slatkin - How to Be More Effective with Functions - PyCon 2015
"Speaker: Brett Slatkin Functions improve readability, encourage reuse, and facilitate refactoring. Python has many unique features that make functions significantly more powerful. This talk will show you the best ways to use functions in Python: when *args is helpful and when it'll crash your programs; how to use generators for arguments and return values; the value of keyword vs. keyword-only arguments; and more! Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Erlang Factory 2016 - Fred Hebert - A Brief History of Time
Tim Ruffles: Solving the real callback hell - Great British Node Conf
Tim Ruffles investigates different approaches to managing and avoiding callback hell.
Droidcon Montreal Jake Wharton - A Few Ok Libraries
Droidcon had its first Canadian edition on April 9-10, 2015 in Montreal. It was organized by Mirego http://www.mirego.com/en We had Jake Wharton telling us more about some Ok Libraries at Droidcon Montreal. A Few "OK" Libraries: This talk will be an in-depth look at Okio—a tiny library for interacting with bytes—and a few of the libraries written on top of it: OkHttp, Retrofit, and a newcomer named Moshi. Okio evolved naturally inside of OkHttp before being split out into its own library. It wraps common patterns behind a friendly API for reading, writing, and processing data. We'll start with some fundamentals of the library and how it can enable you to work very close to raw data with ease. After an introduction to Okio, we will look at three libraries written with it: OkHttp, a modern HTTP client; Retrofit, a high-level HTTP wrapper; and Moshi, a brand new library for serialization. Not only are these libraries powerful on their own, but when combined their efficiency and performance dramatically increase. We'll conclude with demonstration of how to use them in your applications to great effect. - Jake Wharton Android developer for Square working on Square Cash. Has a long-time severe allergy to boilerplate code and for years has been raising awareness on the issue as well as leading efforts to eradicate this horrible disease that plagues modern developers.
Macworld Boston 1997-The Microsoft Deal
Here we see Steve Jobs & the almost bankrupt at the time Apple Computer making a temporary deal with Bill Gates & Microsoft. The crowd was not too happy about it.
F8 2015 - Big Code: Developer Infrastructure at Facebook's Scale
What is it like to build mobile apps at Facebook? Join us as we tour the tool-chain that allows thousands of engineers to build apps faster - and for more platforms - than ever before.
"Ludicrous Speed: Designing For Performance on the JVM" by Cliff Moon
Over the past 3 years the JVM has largely overtaken C++ as the platform of choice for writing high performance software. The JVM / Java can be found powering HFT systems, low latency distributed databases, and real-time analytics platforms in almost every enterprise. During this talk you will come to understand the Java memory and concurrency models, how they interact with modern architectures, and the implications for how you ought to design your software. I will share my experiences designing, scaling and tuning a massive scale real-time analytics system, both the failures and the successes. by Cliff Moon (@moonpolysoft) - Boundary Cliff Moon is the founder and CTO of Boundary. Cliff has lead the building of Boundary's streaming ￼￼￼￼￼￼￼￼￼￼￼￼￼￼ analytics technology, which processes over 2 trillion metrics per day. Previously, Cliff was a leading engineer at Powerset, which was acquired by Microsoft. While there, Cliff helped kick off the NoSQL movement with his open source Dynomite project.
Type-Driven Development in Idris — Edwin Brady
Idris is a general purpose pure functional programming language with dependent types. In Idris, types are a first class language construct, meaning that they can be manipulated and computed like any other language construct. It encourages a type-driven style of development, in which programmers give types first and use interactive editing tools to derive programs. Introductory examples typically involve length-preserving operations on lists, or ordering invariants on sorting. Realistically, though, programming is not so simple: programs interact with users, communicate over networks, manipulate state, deal with erroneous input, and so on. In this talk I will show how advanced type systems allow us to express such interactions precisely, and how they support verification of stateful systems as a result. The talk will include several examples, leading to a verified implementation of a word game (Hangman). I will show how Type-driven Development allows programmers to specify the game rules in a direct and concise style, and how it leads to an implementation, guaranteed to correctly follow the rules by typechecking.
DCNW13 - Vim - I wish I knew how to :q you
Chris has been working with Drupal since 2006, and has experience of developing projects at all levels. Prior to joining Code Enigma he was a senior developer at Capgemini, working on some of Europe's largest Drupal projects. About The Talk Vim - I wish I knew how to :q you If you, like me, spend a fair amount of your time wrangling code, come along to my fun ,hopefully fun!, session and learn why I choose to spend that time in http://www.vim.org/ Vim.The session will cover: Back to basics - why Vim? Advantages (and disadvantages) of using Vim Basic configuration to get you started Drupal specific configuration How to start (and how to quit) Vim :o) The Vim good stuff ™ In the Vim good stuff section, I hope to show you enough of the tips and tricks that I use on a daily basis so that you'll go away eager to learn more!NOTE: I won't be doing a direct comparison of text editors and I'll be deliberately avoiding the "this editor vs that editor" discussion. Chris Maiden @matason http://camp2013.nwdrupal.org.uk/talk/vim-i-wish-i-knew-how-q-you
Angular + React = Speed Dave Smith
Kicking the Complexity Habit • Dan North
This presentation was recorded at GOTO Chicago 2014 http://gotochgo.com Dan North - Agile Troublemaker, Developer, Originator of BDD ABSTRACT Without rigorous care and attention software quickly becomes messy and unmanageable. Even with the best intentions entropy and complexity are a fact of life in growing applications. As in many other contexts it is easier to tackle the symptoms than the cause. Systems Thinking calls this behaviour "Shifting the Burden" and it is more widespread than you might think. From your IDE to your automated build, from DDD’s ACLs to TDD and other TLAs, from backlogs to burn-ups, we are surrounded by props for coping with complexity. As appealing as these are, they also make us less likely to address the underlying problem of complexity itself. Dan believes you can learn to recognise these coping mechanisms for what they are, and intends to set you on the path to simplicating your programming life. Link to slides: http://gotocon.com/dl/goto-chicago-20... https://twitter.com/gotochgo https://www.facebook.com/GOTOConference http://gotocon.com
lvh - Distributed Systems 101 - PyCon 2015
"Speaker: lvh A very brief introduction to the theory and practice of distributed systems. Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
ElixirDaze 2016 - Learn Elixir: Building a Neural Network from Scratch by Karmen Blake
Building a Neural Network from Scratch by Karmen Blake Help us caption & translate this video! http://amara.org/v/IDEa/
The Algebra of Algebraic Data Types
RacketCon 2013: Matthew Flatt - A Dinosaur's Thoughts on Programming Language Evolution
Matthew Flatt's talk at RacketCon 2013.
Cody Roux - Pure Type Systems
Cody Roux's talk for the Boston Haskell Meetup - February 18, 2015 Slides: http://www.slideshare.net/imalsogreg/cody-roux-pure-type-systems-boston-haskell-meetup
The Cython Compiler for Python
The Cython compiler is the most widely used static compiler for Python. It is used to speed up Python code and to extend CPython with fast native extension modules that process huge amounts of data all around the world. This talk by one of the core developers gives an intro to using the compiler and an overview of its major features.
Jeanine Adkisson - Variants are Not Unions
Variants are Not Unions Some of the most confounding design problems occur when a value can be more than one type of thing. Variants, a.k.a. tagged unions, are an elegant solution to this problem that is not supported in an obvious way in Clojure and is not supported in most mainstream languages or databases. I'll demonstrate how and when to use tagged unions in Clojure, including a pattern-matching destructor and use with core.typed and storage in Datomic.
Running a startup on Haskell
Summary Bryan O'Sullivan presents a case study of a small startup that chose Haskell for its server-side code, outlining the advantages and disadvantages of using Haskell to quickly create a solid solution. Bio Bryan O'Sullivan is an Irish hacker, writer, and entrepreneur who lives in San Francisco. He has written books on leading-edge topics in distributed systems and functional programming, including "Mercurial: The Definitive Guide" and the Jolt award winner "Real World Haskell". Most recently, he cofounded and is CTO of MailRank, a San Francisco email productivity company. About the conference Strange Loop is a multi-disciplinary conference that aims to bring together the developers and thinkers building tomorrow's technology in fields such as emerging languages, alternative databases, concurrency, distributed systems, mobile development, and the web.
Stop Drawing Dead Fish
An incredible talk by Bret Victor about the essence of digital art.
Brian Beckman: Don't fear the Monad
Cross posted from msdn's channel 9. Functional programming is increasing in popularity these days given the inherent problems with shared mutable state that is rife in the imperative world. As we march on to a world of multi and many-core chipsets, software engineering must evolve to better equip software engineers with the tools to exploit the vast power of multiple core processors as it won't come for free as it did in the recent past which was predictably based on Moore's law. Of course, learning new ways to think about programming semantics and code patterns are not always straight forward. For example, most imperative programmers (which include most of us who build software for a living...) are somewhat perplexed by the notion of functions as first class data structures that can be combined to create powerful and composable systems. Languages like Haskell are pure functional languages and require programmers to think in a different way, often in a precise mathematical fashion where composing and chaining functions is "the Way". Dr. Brian Beckman, a Channel 9 celebrity, astrophysicist and senior software engineer thought it would be a very good idea to address the complexity of monads in an easy to understand way: a technical conversation at the whiteboard with yours truly for Channel 9. This video interview is the result of Brian's idea that he can in fact remove the fear of monads from anybody who pays attention to his explanation. Of course, you can't just cover monads in a vacuum (category theory is not really addressed here) so the context is functional programming (Brian covers functions and composable functional structures (function chains) and of course monoids and then monads). Tune in. There's a lot to learn here and only Brian can make monads easy to understand for the rest of us!
Making things with maths - Steven Wittens
The browser used to be a meek sandbox, shut off from all the things that native apps could do. But now we've grown up, and with WebGL, Canvas, Web Audio, Device Access and more, we have a lot of power at our fingertips. To really unlock this potential and make all this data dance, we need maths.
Edouard Alligand: Scaling with C++11
As the number of cores per processor increases, software need to be able to execute multiple tasks in parallel in order to benefit from Moore's law. This is not only a question of writing parallel algorithms, but also a matter of designing the application properly to reduce inter-thread dependencies. These dependencies may be very hard to find and are the results of decades of serial programming. Thus, writing truly scalable software is less a question of technical expertise than adopting the appropriate state of mind. This presentation is about the design, techniques and tools used by the team who wrote the hyperscalable database "quasardb." Building upon concrete scalability challenges, the presenter will expose typical multithreading anti-patterns and how to avoid them. The topics covered include: atomics, micro locks, lock-free and wait-free containers, memory management strategies (copy on write, smart pointers, perfect forwarding...), thread local storage, asynchronous I/O, and much more!
Seven Ineffective Coding Habits of Many Programmers
Habits help you manage the complexity of code. You apply existing skill and knowledge automatically to the detail while focusing on the bigger picture. But because you acquire habits largely by imitation, and rarely question them, how do you know your habits are effective? Many of the habits that programmers have for naming, formatting, commenting and unit testing do not stand up as rational and practical on closer inspection. Kevlin Henney examines seven coding habits that are not as effective as programmers believe, and to suggest alternatives.
Speaker: Tim Williams. London Haskell user group. 27th March 2013. The theory and practice of various recursion schemes applied to real world problems. Demonstrating compositional data-types and data-type generic programs by modelling recursive types as fixed points of functors. Code starts with simple list examples and moves quickly on to more problematic topics, such as program analysis, optimisation, memoization, templating and more.
Parsing with Derivatives
(February 9, 2011) Matthew Might focuses on a new way to write parsers and how it will affect computer science in the future. Might discusses these parsers and overall language theory, to help explain how there is demand for better parsing tools and how computer science will be improved in the future. Stanford University: http://www.stanford.edu/ School of Engineering: http://soe.stanford.edu/ Stanford Center for Professional Development: http://scpd.stanford.edu/ Stanford University Channel on YouTube: http://www.youtube.com/stanford
Facts and Myths about Python names and values
The behavior of names and values in Python can be confusing. Like many parts of Python, it has an underlying simplicity that can be hard to discern, especially if you are used to other programming languages. Here I'll explain how it all works, and present some facts and myths along the way. Call-by-reference? Call-by-value? The answer will be clear!
Chef Style DevOps Kungfu
Ths talk explains what DevOps is, and defines a style of practice that comes from the lived experience of many DevOps professionals. It is a collaborative space, where all practitioners of the style can come together to create a reference for how to build up their own DevOps Kung fu, and teach others how to improve theirs. For more info, see https://github.com/chef/devops-kungfu
Framing the Discussion with EDSLs
We will begin with an overview of the Frames library that offers a data frame abstraction for efficiently working with tabular data in Haskell. A close look at an incidental aspect of the Frames implementation will provide an opportunity to think a bit about records and sum types, which will let us work up a technique for designing embedded domain specific languages (EDSLs) that run at top speed whether interpreted as ordinary Haskell values, or used to feed an entirely non-Haskell compiler tool chain for targeting specialized hardware.
Growing a Language, by Guy Steele
Guy Steele's keynote at the 1998 ACM OOPSLA conference on "Growing a Language" discusses the importance of and issues associated with designing a programming language that can be grown by its users. ACM OOPSLA conference Speaker: Guy L. Steele Jr.
Functional Reactive Programming with RxJava
RxJava is a library for composing asynchronous and event-based programs by using observable sequences for the Java VM. It supports Java 6+, Clojure, Scala, Groovy, JRuby, and Java 8 lambdas. In this session, learn how the Netflix API uses RxJava to implement highly concurrent Web services against asynchronous datasources without blocking, synchronization, or thread safety concerns by using declarative functional reactive composition.
Agile is Dead
Dave Thomas was one of the creators of the Agile Manifesto. A year ago, he told us that Agile is Dead. How could this be? Why had he deserted us? And what are we to do? It turns out that while the "Agile" industry is busy debasing the meaning of the word, the underlying values are still strong. In this talk, Dave will draw a distinction, and show us how to reclaim agility for ourselves. As usual, he'll probably end up making some friends, and making some enemies. Which will you be?
"Typed Clojure in Practice" by Ambrose Bonnaire Sergeant
Typed Clojure is an optional type system for Clojure. Typed Clojure is being used in production systems to help programmers verify, document and design correct Clojure code. In this talk, we introduce the goals of Typed Clojure and discuss how effectively Typed Clojure works in practice. We give an overview of the kinds of problems being solved today with Typed Clojure, and where your Clojure projects might benefit from a type system like it. by Ambrose Bonnaire-Sergeant (@ambrosebs) Ambrose is the creator of Typed Clojure.
You and Your Research
You and Your Research is the blueprint for a successful career in any discipline, not just research; in fact, the talk has the nickname “You and Your Career”. In this lecture, Richard Hamming shares his observations on “why do so few scientists make significant contributions and so many are forgotten in the long run?’’ Some of the key ideas include courage, luck, drive (“knowledge and productivity are like compound interest”), a focus on important problems (“If you do not work on an important problem, it’s unlikely you’ll do important work”), open doors, selling the work (“I suggest that when you open a journal, as you turn the pages, you ask why you read some articles and not others”), and much more. This should be required viewing for every high school student.
Damian Conway, "More Instantly Better Vim" - OSCON 2013
http://oreilly.com/go/oscon-js-html5 Once again Damian Conway returns from the untamed wilderness of deepest Vim, bringing with him yet another collection of tips, tools, and tricks to make your text editing still more unspeakably powerful. Don't miss an upload! Subscribe! http://goo.gl/szEauh Stay Connected to O'Reilly Media by Email - http://goo.gl/YZSWbO Follow O'Reilly Media: http://plus.google.com/+oreillymedia https://www.facebook.com/OReilly https://twitter.com/OReillyMedia
Elixir Conf 2014 - Keynote: Elixir by Jose Valim
Help us caption & translate this video! http://amara.org/v/FGYe/
Game Development Development - Michael Nygard & Ragnar Svensson
Clojure for a desktop GUI application. With JavaFX. For game development. And it's all built on top of an in-memory, transactional graph database. One of the biggest game developers in the world needed a new IDE to build games for their engine. Eclipse just wasn't cutting it any more. It may sound a bit nuts to use Clojure for desktop GUIs, but this architecture delivers incredible benefits to the tool developers. About the speakers: You can find Michael Nygard coding, writing, speaking, or thinking about how the Universe works. He has lived with systems in production and learned hard lessons about the importance of operations. Highly-available, highly-scalable commerce systems are his forte. Ragnar Svensson has worked as a game developer for many years, starting out with player mechanics for AAA console games and transitioning into game engine programming, primarily for the mobile and web platforms. He co-founded the game engine Defold, which was acquired by King in 2014. He currently works for King as lead engine developer of the Defold engine.
How technology evolves
Tech enthusiast Kevin Kelly asks "What does technology want?" and discovers that its movement toward ubiquity and complexity is much like the evolution of life.
Midwest.io 2014 - Demystifying Haskell - Andrew Rademacher
This talk was given at Midwest.io 2014. An in-depth examination of the Fibonacci sequence intended to demonstrate the value of Haskell, bust myths about the difficulty of using Haskell and encourage further research and interest in the language. About the Speaker Andrew is a software consultant with experience delivering telemarketing, manufacturing and analytic systems to both web and native platforms.
Reginald Braithwaite - The Not-So-Big Software Design
We Will All Be Game Programmers
Monads and Gonads
Google Tech Talk (more info below) October 14, 2011 Presented by Mark Lentczner. ABSTRACT Want to know a little more about programming Haskell than just the buzz-words? This talk will show you some of the joys coding in Haskell through lots and lots of code examples. No prior experience with Haskell or functional programming required. Just be ready for some strange and wondrous code! Slides: http://www.ozonehouse.com/mark/haskell-amuse-bouche/slides.html Code: https://github.com/mzero/haskell-amuse-bouche (tag v2 matches the video)
Josh Triplett - Porting Python to run without an OS - PyCon 2015
"Speaker: Josh Triplett We've ported Python to run directly on hardware, without an OS, as a testing and exploration environment for firmware, ACPI, and UEFI. This talk will explore porting Python to a new platform, embedding Python, recreating enough of libc and POSIX to run Python without an OS, and binding to platform-specific services. Includes live demo of bare-metal Python, directly driving hardware. Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
CppCon 2014: Herb Sutter "Lock-Free Programming (or, Juggling Razor Blades), Part I"
http://www.cppcon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- Example-driven talk on how to design and write lock-free algorithms and data structures using C++ atomic -- something that can look deceptively simple, but contains very deep topics. (Important note: This is not the same as my "atomic Weapons" talk; that talk was about the "what they are and why" of the C++ memory model and atomics, and did not cover how to actually use atomics to implement highly concurrent algorithms and data structures.) -- Herb Sutter: Author, chair of the ISO C++ committee, software architect at Microsoft. -- Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Bringing Angular Apps to Life with Animation by Miško Hevery
Bringing Angular Apps to Life with Animation On April 3rd, AngularJS 1.1.4 will be released. The primary feature in this release is declarative support for animation in templates. Along with sharing our design decisions and implementation details, we'll show you how to use these new features and how to handle progressive enhancement for older browsers. Miško Hevery works as an Agile Coach at Google where he is responsible for coaching Googlers to maintain the high level of automated testing culture. He is the father of the AngularJS framework (http://angularjs.org) which enhances HTML to make it suitable for building single page (AJAX) web-applications.
"Unconventional Programming with Chemical Computing" by Carin Meier
Take a step back from your normal programming approach and discover a new way of looking at problems. All living organisms information systems are based on chemical processes. What can we learn by using this metaphor of chemistry in our programming? We will answer this question by looking at Artificial Chemical Computing. Building programs based on molecules and chemical reactions, we will explore new ways of thinking and opening ourselves up to innovation. We will discuss the basics of Chemical Programming and even touch on High Order Chemical Programming as well. Code examples will be in the powerful, elegant, and interactive programming language of Clojure, but you will not need to be an expert in the language to enjoy the demos. Come and join us for this adventure in looking at the programming world from a different perspective. Carin Meier COGNITECT @gigasquid Carin started off as a professional ballet dancer, studied Physics in college, and has been developing software for both the enterprise and entrepreneur ever since. She has a strong background in Ruby and Clojure. Her passions lead her to the intersection of the physical and digital world, combining hardware and software, where she has helped clients develop Home Automation Systems as well as written a control library for the Parrot AR Drone in Clojure. She is highly involved in the community and spoken at many conferences, including keynoting at OSCON and Strange Loop. She helps lead the Cincinnati Functional Programmers and is the author of "Living Clojure".
Golang: The good, the bad, & the ugly
With projects like Openshift 3, Google Kubernetes, and Docker written in the go programming language (golang), it's important to understand what that entails. In this session, we'll talk about what it's like to work with the golang every day. We'll share: Lessons we've learned. Benefits and drawbacks of the language. The challenges and rewards of using golang. Fundamental and advanced uses of the language. Development and operational uses of golang.
John Myles White on Fundamental Concepts in Programming Languages
Meetup: http://www.meetup.com/papers-we-love/events/220902753/ Paper: http://www.cs.cmu.edu/~crary/819-f09/Strachey67.pdf Slides: http://bit.ly/1BnBb08 Audio: http://bit.ly/1HAdXci --------------------------------------------------------------------------------------------- Sponsored by Two Sigma (@twosigma) and The Ladders (@TheLaddersDev) --------------------------------------------------------------------------------------------- Description --------------- Strachey's lectures on "Fundamental Concepts in Programming Languages" provided an extremely broad survey of core issues in programming language design that provided much of the terminology we use today, including definitions of the kinds of polymorphism and the kinds of expressions we see in programming languages. Published as a paper many years later, Strachey's lectures provide an especially readable overview of programming languages concepts. Bio ---- John Myles White (@johnmyleswhite) is a Julia hacker who loves thinking about the ways in which the design of technical programming languages influences the way in which we think about statistics and machine learning. He's written two books about machine learning for O'Reilly and works at Facebook.
Keeping a System Running Forever
Fred Hebert http://www.chicagoerlang.com/fred-hebert.html Systems that fail cost a lot of money. We want systems that stay running and do the work they were design to do. How do you build systems that keep going? Forever? In this talk Fred will share his extensive experience with keeping systems alive, running, and fighting the good fight.
Lenses, Folds, and Traversals
Slides: http://comonad.com/haskell/Lenses-Folds-and-Traversals-NYC.pdf This was a talk I gave at the second New York Haskell User Group Meeting (http://www.meetup.com/NY-Haskell/) on the new lens library, which provides a highly composable toolbox for accessing and modifying multiple parts of data structures. Starting with building blocks such as fmap and (.), we build up combinators suitable for working with a wide array of data structures. These generalize the notions you already know how to use into a form that is easier to compose and simultaneously allow them to be used for monomorphic containers such as Data.Text. All without compromising on your ability to reason about them using laws! Finally, once I've built up some foundations, I do a bit of a deep dive, exploring consequences of this design. In particular we discuss the efficient generic programming programming framework exported by lens, and type-safe Traversal-based zippers. Familiarity with the Applicative and Traversable classes from the Haskell base libraries will be helpful (links provided below), but a basic understanding of the concepts get introduced as I go along. Useful (but not mandatory) references: The lens library and documentation: http://hackage.haskell.org/package/lens A previous, more introductory talk on how to use the lenses Edward Kmett wrote for the scalaz in the Scala programming language: https://www.youtube.com/watch?v=efv0SQNde5Q The original Applicative paper: http://www.soi.city.ac.uk/~ross/papers/Applicative.pdf Lots of information on Traversable: http://www.cs.ox.ac.uk/jeremy.gibbons/publications/iterator.pdf A write-up of this talk, as presented at the Bay Area Haskell Users Group: http://google-opensource.blogspot.com/2012/10/lenses-folds-and-traversals-haskell.html The original Keynote version of the slides are available from http://comonad.com/haskell/Lenses-Folds-and-Traversals-NYC.key Thanks go to Johan Kiviniemi, who worked magic when it came to cleaning up the audio for this recording!
Fighting viruses, defending the net
It's been 25 years since the first PC virus (Brain A) hit the net, and what was once an annoyance has become a sophisticated tool for crime and espionage. Computer security expert Mikko Hyppönen tells us how we can stop these new viruses from threatening the internet as we know it.
Programming is terrible—Lessons learned from a life wasted. EMF2012
http://programmingisterrible.com/ http://twitter.com/tef_ebooks/ A bad programmer talks about bad programming, from EMF 2012 (http://twitter.com/emfcamp/) Slides (PDF) — https://github.com/tef/emfcamp2012/raw/master/programming_is_terrible.pdf Slides (keynote format) — https://github.com/tef/emfcamp2012/blob/master/programming_is_terrible.key Draft script — https://github.com/tef/emfcamp2012/blob/master/programming_is_terrible.rst
Concurrency Anti-patterns in Scala
Blake Matheny approaches his talk at NEScala with a collection of trial-and-error experiences he's acquired as the VP of Engineering at Tumblr (who for the past year and half has adopted Scala as their primary backend development language). Blake draws on actual code used at Tumblr, describes their implications in a server context, and shows us where things have gone wrong and how they were corrected. This talk will be most pertinent to engineers who build backend service applications, but should be of interest to anyone looking to find additional methods for troubleshooting code in Scala. ** Visit our site for more content on Scala, including the rest of the presentations from NE Scala 2013: http://marakana.com/s/tags/scala
Jepsen IV: Hope Springs Eternal • Kyle Kingsbury
This presentation was recorded at GOTO Chicago 2015 http://gotochgo.com Kyle Kingsbury - Author of Jepsen ABSTRACT Stateless applications aren't: they rely on other systems storing and transforming shared state correctly. On the basis of documentation and reputation we assume that our clients and database systems comprise a safe, [...] Download slides and read the full abstract here: http://gotocon.com/chicago-2015/presentation/Jepsen%20IV:%20Hope%20Springs%20Eternal https://twitter.com/gotochgo https://www.facebook.com/GOTOConference http://gotocon.com
Clojure Concurrency - Rich Hickey
A presentation by Rich Hickey to the Western Mass. Developers Group on Clojure and concurrency. Brief overview of Clojure, discussion of concurrency issues, locking, and immutabiity. In-depth look at Clojure's refs, transactions and agents. Demonstration and review of code for a multithreaded ant colony simulation.Be sure to grab the slides and code in order to follow along.Thanks to Shawn Fumo for working on this video.
Reactive Programming Overview (Jafar Husain from Netflix)
HackHands.com interviews Jafar Husain (Technical Lead at Netflix) about Reactive Programming concepts and it's usage on Netflix.com. About the Interviewee: Jafar Husain is a highly skilled software developer with twelve-years of experience designing and developing enterprise software for prestigious corporations and organizations. Jafar Husain currently works for Netflix.
Optimizing the Emergent Structures of C++
We are confronted today with the increasing complexity of our C++ software systems. To manage this complexity and build larger applications and systems, C++ strives to form emergent structures (often found in nature, such as snowflakes' symmetrical structures), where simple patterns combine to form a remarkably complex and powerful system. These structures provide both a means to limit the complexity of each component and the essential economies of scale we rely on when developing software. From handheld devices to warehouse-sized data centers, motivated by smaller devices and increased concerns over power consumption, we are relying upon C++ to deliver these complex systems with unmatched efficiency. Our optimizing compilers today are more important than ever before and are utterly opaque to most practicing programmers. Compounding matters, the very emergent structures which allow C++ systems to scale for humans often provide unique and unsolved challenges to optimization. In this talk, I will start with a brief overview of how modern optimizing compilers work with C++ code at a very high level. I will then walk through the specific structures and patterns of C++ code, which are at the core of forming emergent structures out of simple, elegant elements. I will also address how these interactions can be effectively modeled and analyzed by a compiler to produce efficient final programs. All of this will be illustrated by a collection of real world case studies, which are broadly applicable and show up throughout modern C++ code bases. My goal is to give a framework for understanding these interactions both in the C++ code and the optimizing compiler, so that programmers are aware of the implications posed by these patterns. Finally, I will introduce a set of principles and techniques for designing and implementing C++ programs and libraries to specifically clear the way for modern optimizers while retaining the simplicity of each component and the power of the combined whole.
Parallel Programming, Fork Join, and Reducers - Daniel Higginbotham (with slides)
If you don't know your work/span from your fork/join, this talk is for you! By attending this introduction to "thinking parallel," you'll learn why parallel programming matters, how to think about performance, and how to tackle real-world concerns. You'll learn about how the fork/join framework embodies best practices. And of course, you'll learn how Clojure implements these ideas with reducers.
Writing Quick Code in C++, Quickly
Day 1 - Contemporary computer architectures make it possible for slow code to work reasonably well. They also make it difficult to write really fast code that exploits the CPU amenities to their fullest. And the smart money is on fast code—we're running out of cool things to do with slow code, and the battle will be on doing really interesting and challenging things at the envelope of what the computing fabric endures. So how to write quick code, quickly? Turns out it's quite difficult because today's complex architectures defy simple rules to be applied everywhere. It is not uncommon that innocuous high-level artifacts have a surprisingly high impact on the bottom line of an application's run time (and power consumed). This talk is an attempt to set forth a few pieces of tactical advice for writing quick code in C++. Applying these is not guaranteed to produce optimal code, but is likely to put it reasonably within the ballpark. These tips are based on practical experience but also motivated by the inner workings of modern CPUs.
The Future of Programming
How did our industry start, what paths did it take to get to where we are, and where is it going. What big problems did programmers encounter in the past? How were they solved? And how do those solutions impact our future? What mistakes have we made as a profession; and how are we going to correct them. In this talk, Uncle Bob describes the history of software, from it’s beginnings in 1948 up through the current day; and then beyond. By looking at our past trajectory, we try to plot out where our profession is headed, and what challenges we’ll face along the way. Robert C. Martin (Uncle Bob) has been a programmer since 1970. He is the Master Craftsman at 8th Light inc, an acclaimed speaker at conferences worldwide, and the author of many books including: The Clean Coder, Clean Code, Agile Software Development: Principles, Patterns, and Practices, and UML for Java Programmers.
The How and Why of Fitting Things Together - Joe Armstrong
Erlang Factory SF Bay Area 2013 More info and slides on the website: http://www.erlang-factory.com/conference/SFBay2013/talks Software is difficult because the parts don't fit together. Why is this? Can we do anything about this? And what's this got to do with Erlang? Come to my talk and you'll find out!
DConf 2014: High Performance Code Using D (Walter Bright)
Go for Pythonistas
In this talk Francesc Campoy Flores presents Go for Pythonistas. Slides are available at http://talks.golang.org/2013/go4python.slide He looks at the similarities and differences between Python and Go, skipping the basics and focusing on some advanced, in-depth topics. Plus, we'll get our hands dirty with some Go exercises. It displays some techniques typical from dynamic languages as generators, decorators, and monkey patching and how they can be implemented in Go.
Timothy Baldridge - Core.Async
The new Core.Async library in Clojure opens a realm of new possibilities for users of the language. This talk will start with an overview of Core.Async, and then show several examples ported from other CSP languages, such as Go and JSCP. The talk will end with a example program that runs on both Clojure and ClojureScript, leveraging this new library. Timothy is a polyglot programmer with a passion for compilers and fast code. He is the author of clojure-py, Mjolnir, and several other compiler and interpreter related projects. He is an employee of Relevance Inc., and loves to discuss new programming concepts and ideas with anyone who will listen.
What the f*** JS
Lambda Days 2015 - Norbert Wójtowicz - ClojureScript + React.js (...)
Lambda Days 2015 - Norbert Wójtowicz - ClojureScript + React.js: How I learned to stop worrying and love the browser Norbert Wójtowicz Software Developer at Base CRM Norbert Wójtowicz is a developer at Base CRM, whose magic 8-ball predicts that Clojure and ClojureScript will be in your future toolbox. You can find his code and ramblings in various corners of the internet, under the felicitous handle @pithyless. ClojureScript + React.js: How I learned to stop worrying and love the browser. Over the last few years, there has been a stronger emphasis on functional programming languages and constructs in mainstream programming. The rise of FP popularity is not due to concurrency (although still valid), but the recognition that minimizing side-effects yields to smaller code that is easier to test and reason about. ClojureScript finally brings that perspective to the front-end world. This talk is an introduction to a different kind of front-end development. Together, we will explore how ClojureScript helps accelerate front-end development and how to avoid the most common pitfalls; a molotov cocktail of information and pizazz to put you on the fast-track towards web development nirvana.
Google I/O 2012 - Go Concurrency Patterns
Rob Pike Concurrency is the key to designing high performance network services. Go's concurrency primitives (goroutines and channels) provide a simple and efficient means of expressing concurrent execution. In this talk we see how tricky concurrency problems can be solved gracefully with simple Go code. For all I/O 2012 sessions, go to https://developers.google.com/io/
Hammock Driven Development - Rich Hickey
Rich Hickey's second, "philosophical" talk at the first Clojure Conj, in Durham, North Carolina on October 23rd, 2010. Many thanks to Matt Courtney, who graciously provided the equipment and expertise that made this recording possible.
Polymer and modern web APIs: In production at Google scale
The latest version of Polymer is fast and lean. Learn how teams at Google have successfully launched sites using Polymer and the latest platform APIs: Web Animations, Service Workers for offline and push notifications, and material design. And if you're new to Polymer we'll show you how to get started building mobile-first apps.
Designing for Performance • Martin Thompson
This presentation was recorded at GOTO Chicago 2015 http://gotochgo.com Martin Thompson - High-Performance Computing Specialist ABSTRACT What does it really mean to design software for high-performance? Performance is such a generic and misunderstood subject. In this talk the subject of performance will be explored. We will focus on what is means to achieve [...] Download slides and read the full abstract here: http://gotocon.com/chicago-2015/prese... https://twitter.com/gotochgo https://www.facebook.com/GOTOConference http://gotocon.com
CppCon 2014: Chandler Carruth "Efficiency with Algorithms, Performance with Data Structures"
http://www.cppcon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- Why do you write C++ code? There is a good chance it is in part because of concerns about the performance of your software. Whether they stem from needing to run on every smaller mobile devices, squeezing the last few effects into video game, or because every watt of power in your data center costs too much, C++ programmers throughout the industry have an insatiable desire for writing high performance code. Unfortunately, even with C++, this can be really challenging. Over the past twenty years processors, memory, software libraries, and even compilers have radically changed what makes C++ code fast. Even measuring the performance of your code can be a daunting task. This talk will dig into how modern processors work, what makes them fast, and how to exploit them effectively with modern C++ code. It will teach you how modern C++ optimizers see your code today, and how that is likely to change in the coming years. It will teach you how to reason better about the performance of your code, and how to write your code so that it performs better. You will even learn some tricks about how to measure the performance of your code. -- Chandler Carruth leads the Clang team at Google, building better diagnostics, tools, and more. Previously, he worked on several pieces of Google’s distributed build system. He makes guest appearances helping to maintain a few core C++ libraries across Google’s codebase, and is active in the LLVM and Clang open source communities. He received his M.S. and B.S. in Computer Science from Wake Forest University, but disavows all knowledge of the contents of his Master’s thesis. He is regularly found drinking Cherry Coke Zero in the daytime and pontificating over a single malt scotch in the evening. -- Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Zachary Kessin - Using Logic Programming Tools to Drive Property-based Testing
PBT with tools like QuickCheck and Proper are quite powerful, but building the models to test against is still probably the hardest part. I aim to use a Logic Programming tool (Kanrem or Prolog) to create the model and validate the results. Talk objectives: To show how to use the powerful tools of logic programming and to how to build models to test Erlang code. Target audience: This will appeal to those who really enjoy programming languages and new tools.
Tangible Functional Programming
Google Tech Talks November, 7 2007 ABSTRACT We present a user-friendly approach to unifying program creation and execution, based on a notion of "tangible values" (TVs), which are visual and interactive manifestations of pure values, including functions. Programming happens by gestural composition of TVs. Our goal is to give end-users the ability to create parameterized, composable content without imposing the usual abstract and linguistic working style of programmers. We hope that such a system will put the essence of programming into the hands of many more people, and in particular people with artistic/visual creative style. In realizing this vision, we develop algebras for visual presentation and for "deep" function application, where function and argument may both be nested within a structure of tuples, functions, etc. Composition gestures are translated into chains of combinators that act simultaneously on statically typed values and their visualizations. Speaker: Conal Elliott Most of my research is aimed at supporting the creation of interactive synthetic media content, including computer animation, human-computer interaction, images, 2D and 3D geometry, and programmable shaders. In all cases, I aim to preserve or improve on the flexibility and performance of mainstream programming approaches, while greatly simplifying the creation process. Synthetic media programs are almost always implemented in sequential, imperative (often object-oriented) languages. My research explores use of declarative languages, resulting in much simpler and more reusable and composable programs. These languages are also more amenable to execution on parallel architectures such as modern graphics processors, because declarative languages abstract away from order of execution, removing the accidental sequentiality found in imperative programs. Even on sequential machines, declarative formulations have much simpler mathematical semantics, which facilitates automatic optimization. They also tend to be spatially and temporally continuous (resolution-independent), allowing them to adapt naturally to machines with different speeds and display resolutions. After exploring explicit programming of synthetic media content for several years, I'm now also keenly interested in supporting artists. The goal of my new new research agenda is to give artists access to the expressive power of computers and programming languages, while retaining an artist's working style. I mean "artist" in a broad sense, in contrast to the verbal and sequential style of an engineer. (I don't mean to suggest that people fit neatly into these two categories.) My ideal audience includes graphic designers, musicians, and children -- really, the playful and curious in all of us. This abstract has 2796 This abstract has 2820
Apple fanboys are foolish people
Richard Stallman in Zurich: The father of the movement for free software about his rebellion against administrative slack at MIT, about "foolish" Apple aficionados, current fights against evil software companies and Swiss national hero William Tell, who could serve as a role model in the fight against an unjust copyright. By the way: After the camera was turned off, Richard and I talked about some other topics: Ads in the web and his Free Software song. This part is available as audio recording here, just skip to minute 20:37: http://www.stadtfilter.ch/DigitalPodcast/Digital20160517
Melanie Warrick - Neural Nets for Newbies - PyCon 2015
"Speaker: Melanie Warrick Neural networks have regained popularity in the last decade, but they get dismissed as being too complicated to understand and implement. This talk breaks down the neural net structure as simply as possible, so you have a framework on which to grow your knowledge in the space. I will put neural nets in the context of real-world applications and share Python packages and code where you can get started building your own. Coming out this talk you won't know everything about neural nets, but you will walk away with a solid foundation and some resources on where to go next to learn more. Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Katy Levinson Defcon 20 - Robots: You're Still Doing It Wrong
By popular demand, Defcon's angry little roboticist is back with more stories of robot designs gone awry that make practical lessons on making better robots. Drinking will happen: vodka-absconding scoundrels are not invited. This talk will cover material assuming the average audience member is a relatively intelligent coder with a high-school physics/math background and has seen linear algebra/calculus before. The intent is to navigate people new to robotics around many lessons my teams and I learned the "hard way," and to introduce enough vocabulary for a self-teaching student to bridge the gap between amateur and novice professional robotics. It will not cover why your Arduino doesn't work when you plugged your USB tx into your RS232 tx.
The Future Doesn't Have to Be Incremental
When thinking about the future, you can't do better than Alan Kay. In The Future Doesn't Have To Be Incremental, Kay describes how Xerox PARC was able to develop so many new technologies in such a short time, including the personal computer, bitmap displays, GUI, desktop publishing, word processing, laser printing, Ethernet, and object oriented programming. The key was a culture focused on invention - that is, fundamentally new research - instead of incremental innovation. Invention requires a significantly higher investment of money, much longer time frames, and a different approach to problem solving.
ClojureScript for Skeptics - Derek Slager
Lambda Jam 2015 - Robby Findler - Racket: A Programming-Language Programming Language
Racket is the best programming language that embraces the premise that there is no best programming language. In other words, Racket is designed to support the creation of programming languages which can then be used to build programs. Using Racket, we have built program languages ranging from large, general-purpose languages matching particular programming paradigms to small, specialized programming languages designed for just a single file in some larger program. In this talk, I will bring across how it feels to program in such a language, discuss some of the technical support Racket has to make such programming practical, and show how Racket’s standard libraries have embraced this perspective, enabling us to include lots of batteries. Robby is an associate professor of computer science at Northwestern University and received his PhD from Rice University in 2002. He is the author or two textbooks, one on introductory programming and one on operational semantics. Robby is one of the core developers of Racket and has helped shape the design the language since its inception in 1994. For more on Lambda Jam, visit http://www.lambdajam.com
Keynote - Jacob Kaplan-Moss - Pycon 2015
Jane Street Capital is a proprietary trading company that has shifted from developing software in mainstream programming languages to developing software almost entirely in OCaml, a statically typed functional programming language that has only modest industrial use. The scope of the enterprise is small but growing: Jane Street now has over 30 OCaml programmers that have collectively written hundreds of thousands of lines of OCaml code. OCaml is used for building everything from trading systems to research infrastructure to user interfaces to systems administration tools. This talk will discuss the motivations behind Jane Street's adoption of OCaml, and why we think that statically typed functional programming languages are a good ﬁt for the world of trading and ﬁnance.
OSCON Java 2011: Josh Bloch, "Java: The Good, Bad, and Ugly Parts"
In my technical presentation ("The Evolution of Java: Past, Present, and Future"), I'll be discussing all of the changes to the Java programming language since its inception. In this this keynote, I'll focus my attention on the starting point: I'll present my candidates for the best and worst features in the platform as it was originally released (JDK 1.0), and explain the reasoning behind my choices. Some of my choices may be obvious, but others will likely surprise you. A splendid time is guaranteed for all. Josh Bloch Google Joshua Bloch is a software architect in the Open Source Program Office at Google, author of the bestselling, Jolt Award-winning "Effective Java" (Addison-Wesley, 2001; Second Edition, 2008), and coauthor of "Java Puzzlers: Traps, Pitfalls, and Corner Cases" (Addison-Wesley, 2005) and "Java Conurrency in Practice" (Addison-Wesley, 2006). He was previously a Distinguished Engineer at Sun Microsystems, where he led the design and implementation of numerous Java platform features including the Java Collections Framework and JDK 5.0 language enhancements. He holds a Ph.D. from CMU and a B.S. from Columbia.
Redemption from Callback Hell
"Apparatus: A Hybrid Graphics Editor / Programming Environment" by Toby Schachman
An interactive diagram can be an effective way to communicate a mental model, because it can convey a way of seeing a problem or system. Currently, to create an interactive diagram one must write code to procedurally draw the diagram and respond appropriately to user input. Writing this code can take hours or days. Apparatus aims to reduce the time to create an interactive diagram from hours to minutes. Apparatus combines the direct manipulation capabilities of a vector graphics editor with the dataflow capabilities of a spreadsheet. Through this hybridization, Apparatus supports both spatial and symbolic ways of working in tandem. Dataflow defines the state space of a diagram, algebra driving geometry. Dragging shapes moves through this state space, geometry driving algebra. Instead of function calls or object-oriented inheritance, Apparatus uses a "call by copying" pattern for diagram reuse. Reused diagrams do not need to be explicitly parameterized. Instead of loops, Apparatus uses spreads which allow any value to exist in a "superposition". This allows shapes to be looped over implicitly. By decomposing shapes into paths of points, it also enables Apparatus to plot curves. Toby Schachman COMMUNICATIONS DESIGN GROUP Toby Schachman is an artist and interaction designer interested in new ways of seeing. He currently is a researcher in the Communications Design Group working on alternative interfaces for programming. He holds a master’s degree from the Interactive Telecommunications Program at NYU and a bachelor’s degree from MIT. He is a previous Eyebeam fellow.
Do Schools Kill Creativity?
Sir Ken Robinson makes an entertaining and profoundly moving case for creating an education system that nurtures (rather than undermines) creativity.
Barbara Liskov: Programming the Turing Machine
Barbara Liskov, Professor of Electrical Engineering and Computer Science at the Massachusetts Institute of Technology, discusses "Programming the Turing Machine" in a lecture given on the occasion of Princeton University's centennial celebration of Alan Turing. Learn more at www.princeton.edu/turing #turingprinceton
Java 8 Language Capabilities, What's in it for you?
Recorded at SpringOne2GX 2014. Speaker: Venkat Subramaniam No Slides at speaker request There is a good amount of excitement about the new version of Java. The big evolution of course is the lambda expressions. In this presentation we will dive into the language features in Java 8, take a look at some of their nuances, and look at ways to put them to good use. In addition to looking at lambdas we will also dive into the Streams capabilities and also some of the features in Java 8 that make all these possible. TIMES September 11, 2014 10:30 AM - 12:00 PM Dallas Ballroom E-F SCHEDULE
Crossing Language Barriers with Julia, SciPy,IPython | EuroSciPy 2014 | Stephen G Johnson
Achieving Your Childhood Dreams
Carnegie Mellon Professor Randy Pausch (Oct. 23, 1960 - July 25, 2008) gave his last lecture at the university Sept. 18, 2007, before a packed McConomy Auditorium. In his moving presentation, "Really Achieving Your Childhood Dreams," Pausch talked about his lessons learned and gave advice to students on how to achieve their own career and personal goals.
Field of Rationality and Category Theory, Michał Heller
The field of rationality idea was put forward by Joseph Życiński as a context in which the questions: "How do mathematical objects exist?" and "Why is mathematics so effective in the physical sciences?" could be better understood. The idea never went beyond its seminal stage. In the present study I try to make it less fuzzy by relating it to the ontologically interpreted category theory, where "ontological interpretation" should be understood "in the sense of Quine". Roughly speaking, the ontology in the sense of Quine does not aspire to establish what does exist, but rather what a given theory or doctrine assumes there exists. To construct such an ontology, one should paraphrase a given doctrine into the first order logical calculus and look for those variables that are bound by the existential quantifiers. Only those entities that correspond to such variables are postulated to exist. However, in principle each topos has its own "internal logic". Consequently, we should apply Quine's program to each such category individually (by employing its own internal logic), and speak about the ontology in the sense of Quine characteristic for a given category in terms of a given logical calculus (if Quine's program is realisable in this logic). However, the Quine ontological program does not directly refer to the internal logic of a given theory, but rather to the logic with the help of which we are interpreting this theory (the external or meta-logic), and this is expected to be the standard classical logic. This is also the case with respect to category theory. When developing this theory, for instance by proving theorems, we are using standard logical laws of inference. This is why we seem entitled to ontologically interpret category theory strictly following Quine's recipe (i.e. with the help of the first order logical calculus), but we should be aware that this could be conditioned by the fact that our brain is a macroscopic object embedded into the world having the ontology characteristic for the category of sets. Having these caveats in mind I sketch "ontological commitments" of category theory and briefly signal some underlying philosophical problems. *** This talk was delivered during the conference ���The Limits of Physics and Cosmology” organized by Copernicus Center for Interdisciplinary Studies. There exist various kinds of limits which are inherent in cosmological research and physics. The most conspicuous one is connected with scientific method itself. It manifests itself during attempts to construct (or discover) suitable mathematical structures to model the physical world. However, this limit may be even more profound. Over the past 300 years we have become accustomed to the mathematical and empirical method which has proven to be uncannily successful in describing the enclosing universe. But is there a fundamental limit to the method itself which is intrinsic to the structure of the world? Another group of limits which are more connected to ourselves – as human beings – are conceptual ones. The two monumental theories of physics of the 20th century – General Relativity and Quantum Mechanics - are incompatible and this inconsistency is not only on the mathematical level, but also on the conceptual. Usually scientists believe that the reconciliation between the relativist and quantum realms is possible. But is there a conceptual limit within ourselves as elements of the world?
JVMLS 2015 - Multi-Language Runtime
JVMLS 2015 - Multi-Language Runtime - Mark Stoodley The JVM Language Summit is an open technical collaboration among language designers, compiler writers, tool builders, runtime engineers, and VM architects. In 2015, it convened at Oracle's Santa Clara, CA campus on August 10-12.
Tom Eastman - Serialization formats are not toys - PyCon 2015
"Speaker: Tom Eastman It’s not in the OWASP Top 10, but you don’t have to look far to hear stories of security vulnerabilities involving deserialization of user input. In this talk I’ll go over what the threat is and how you might be making yourself vulnerable. I’ll cover the features (not bugs: features) of XML, YAML, and JSON that make them surprisingly dangerous, and how to protect your code from them. Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Rob Story - Up and Down the Python Data and Web Visualization Stack
Doing with Images Makes Symbols
How humans learn and how to build user interfaces that support it. “The parts of the body you want to have learn don’t understand English.”
"How NOT to Measure Latency" by Gil Tene
Time is Money. Understanding application responsiveness and latency is critical but good characterization of bad data is useless. Gil Tene discusses some common pitfalls encountered in measuring latency and response time behavior. He introduces how simple, open sourced tools can be used to improve and gain higher confidence in both latency measurement and reporting. Gil Tene AZUL SYSTEMS @giltene Gil Tene is CTO and co-founder of Azul Systems. He has been involved with virtual machine and runtime technologies for the past 25 years. His pet focus areas include system responsiveness and latency behavior. Gil is a frequent speaker at technology conferences worldwide, and an official JavaOne Rock Star. He pioneered the Continuously Concurrent Compacting Collector (C4) that powers Azul's continuously reactive Java platforms. In past lives, he also designed and built operating systems, network switches, firewalls, and laser based mosquito interception systems.
"The Mess We're In" by Joe Armstrong
Joe Armstrong is one of the inventors of Erlang. When at the Ericsson computer science lab in 1986, he was part of the team who designed and implemented the first version of Erlang. He has written several Erlang books including Programming Erlang Software for a Concurrent World. Joe has a PhD in computer science from the Royal Institute of Technology in Stockholm, Sweden.
Keynote at PyCon Brasil 2015 (Screencast)
A discussion of asyncio, the new async/await syntax in Python 3.5, and a future view of async Python without the asyncio package. Plus, live coding. Code samples at https://gist.github.com/dabeaz/fc5c08040effca799759
Whence Complexity? - Michael Nygard
Quantum Mechanics and General Relativity don't agree on much, but both claim that every physical process is perfectly reversible. The Second Law of Themodynamics says, "Not likely!" The Second Law may win in the long run, but today, at (nearly) every scale, we see structure instead of randomness; complexity instead of chaos. It seems as though the natural state of the universe is ordered to a preposterously unlikely degree. Michael intends to explain it all.
Why C++ Sails When the Vasa Sank
Source: http://tech.yandex.ru/events/cpp-party/june-msk/talks/1954/ I especially like 36:58 The Vasa was a 17th-century Swedish warship which suffered such feature creep during construction that it sank shortly after leaving the harbour on its maiden voyage. In the early 1990s, the C++ standardisation committee adopted the Vasa as a cautionary tale, discouraging prospective language extensions with "Remember the Vasa!" Yet C++ continued to grow, and by the time C++ was standardised, its complexity made the Vasa look like a rowboat. The Vasa sank, however, while C++ cruised, and it looks likely to continue doing so even as the latest revised standards (C++11 and C++14) add dozens of new features, each with its own idiosyncrasies. Clearly, C++ has gotten some important things right. In this talk, Scott Meyers considers the lessons to be learned from the ongoing success of a complex programming language that's over 30 years old, yet very much alive and kicking.
Patterns of Effective Teams
Some teams are orders of magnitude more effective than others, turning around business solutions in days or even hours. Their secret is a combination of smart technology choices, great development habits and a powerful team dynamic. In this talk Dan describes a number of patterns of behaviour that he's identified working with some great teams, beyond the basics of co-location, stand-ups and pair rotation. You'll gain a new appreciation for old techniques like code reviews, and even working in silos won't seem so bad!
Elixir: The Power of Erlang, the Joy of Ruby
I'm a language nut. I love trying them out, and I love thinking about their design and implementation. (I know, it's sad.) I came across Ruby in 1998 because I was an avid reader of comp.lang.misc (ask your parents). I downloaded it, compiled it, and fell in love. As with any time you fall in love, it's difficult to explain why. It just worked the way I work, and it had enough depth to keep me interested. Fast forward 15 years. All that time I'd been looking for something new that gave me the same feeling. Then I came across Elixir, a language by José Valim, that puts a humane, Ruby-like syntax on the Erlang VM. Now I'm dangerous. I want other people to see just how great this is. I want to evangelize. So come along and let me show you the things that I think make Elixir a serious alternative for writing highly reliable, scalable, and performant server code. And, more important, let me show you some fun stuff.
Hey Underscore, You're Doing It Wrong!
Brian Lonsdorf has a love-hate relationship with Underscore.js. Yes, it offers a bunch of tools included in today's functional programming paradigm (like map, filter, reduce, take, drop, compose, etc.), but in Underscore the functions are sometimes verbose and unintuitive. It claims to be a functional programming language, but how true is that? Despite certain characteristics, Brian offers some solutions for using Underscore productively. He plays a bit of catchup for the functional programming newbie, but then dives into the denser more theoretical concepts. **Follow along with Brian's slides: http://mrkn.co/5nvjz
"Specter: overcome your fear of nested Clojure data" by Nathan Marz
Clojure revolves around immutable values and manipulation of those values. However, it does not provide good mechanisms for manipulating combinations of those values: like a map of sequences of maps of maps. Code that aims to manipulate these nested data structures complects navigation code with the desired query or transformation. Code like this is painful to write and ugly to read. Specter is a library that makes querying and transformation of nested data structures simple, easy, and efficient. At its core it abstracts away the concept of data structure navigation and makes these navigations highly composable. Specter can manipulate any of Clojure's maps, sequences, records, and sets, and by hooking into Specter's protocols you can use it to manipulate any data structure. On top of all this, Specter is highly performant: for example, Specter's equivalent to update-in runs 5x faster. Once you've used Specter, it's hard to imagine programming Clojure without it. Nathan Marz RED PLANET LABS, INC. @nathanmarz Nathan is the creator of the open source projects Apache Storm and Cascalog. He is the author of the book "Big Data: principles and best practices of scalable realtime data systems". He was the lead engineer of BackType until BackType was acquired by Twitter. At Twitter, he created the streaming compute team, a core infrastructure team within the company. He left Twitter in 2013 to work on a new startup. When not coding, you can often find him 3500 feet overhead, flying a small plane and enjoying the view.
Node.js in 20 Minutes
David Nolen | TXJS 2015
Let's use video to reinvent education
Salman Khan talks about how and why he created the remarkable Khan Academy, a carefully structured series of educational videos offering complete curricula in math and, now, other subjects. He shows the power of interactive exercises, and calls for teachers to consider flipping the traditional classroom script -- give students video lectures to watch at home, and do "homework" in the classroom with the teacher available to help.
The Continuum Hypothesis and the search for Mathematical Infinity, W. Hugh Woodin
Does the Continuum Hypothesis have an answer? This question is pointed out by professor W. Hugh Woodin. He admits that 15 years ago he thought it was false. Has his opinion changed? You can see from this lecture. William Hugh Woodin is an American mathematician and set theorist at Harvard University. He has made many notable contributions to the theory of inner models and determinacy. A type of large cardinal, the Woodin cardinal, bears his name.
CppCon 2015: Chandler Carruth "Tuning C++: Benchmarks, and CPUs, and Compilers! Oh My!"
http://www.Cppcon.org — A primary use case for C++ is low latency, low overhead, high performance code. But C++ does not give you these things for free, it gives you the tools to control these things and achieve them where needed. How do you realize this potential of the language? How do you tune your C++ code and achieve the necessary performance metrics? This talk will walk through the process of tuning C++ code from benchmarking to performance analysis. It will focus on small scale performance problems ranging from loop kernels to data structures and algorithms. It will show you how to write benchmarks that effectively measure different aspects of performance even in the face of advanced compiler optimizations and bedeviling modern CPUs. It will also show how to analyze the performance of your benchmark, understand its behavior as well as the CPUs behavior, and use a wide array of tools available to isolate and pinpoint performance problems. The tools and some processor details will be Linux and x86 specific, but the techniques and concepts should be broadly applicable. -- Chandler Carruth leads the Clang team at Google, building better diagnostics, tools, and more. Previously, he worked on several pieces of Google’s distributed build system. He makes guest appearances helping to maintain a few core C++ libraries across Google’s codebase, and is active in the LLVM and Clang open source communities. He received his M.S. and B.S. in Computer Science from Wake Forest University, but disavows all knowledge of the contents of his Master’s thesis. He is regularly found drinking Cherry Coke Zero in the daytime and pontificating over a single malt scotch in the evening. -- Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Hacker Way: Rethinking Web App Development at Facebook
Delivering reliable, high-performance web experiences at Facebook's scale has required us to challenge some long-held assumptions about software development. Join us to learn how we abandoned the traditional MVC paradigm in favor of a more functional application architecture.
Make Simple Tasks Simple!
C++ faces two challenges: Helping programmers address the most demanding tasks in terms of performance, scale, and dependability. It must also help programmers be productive writing ordinary maintainable code. There is much more "ordinary code" than there is performance-critical code. Thus, C++ must make simple tasks simple while not getting in the way of tuning software for the last byte and last cycle where that's necessary. This talk focuses on what C++11 and C++14 offers to simplify programming: auto, range-for loops, move semantics, futures, concepts, and more. However, the focus is not primarily on language features: the key is programming: how can we write better, more readable, efficient, and more maintainable code? If you think that the essence of C++ is clever pointer manipulation and huge class hierarchies you may be in for a few surprises.
Category Theory by Tom LaGatta
Read more information here: http://www.hakkalabs.co/articles/mathematics-lectures-for-software-engineers-category-theory-by-tom-lagatta Filmed at the March 11, 2014 LispNYC meetup at Meetup HQ in NYC.
Stop Writing Classes
Classes are great but they are also overused. This talk will describe examples of class overuse taken from real world code and refactor the unnecessary classes, exceptions, and modules out of them.
Concurrency in Rust
Alex Crichton, of Mozilla Research, presents on the low level workings of concurrency in the Rust programming language. Slides: http://people.mozilla.org/~acrichton/rust-talk-2014-08-27/#/ Presented at Pittsburgh Code & Supply, August 28th 2014. Find more at http://codeandsupply.co
Arne Martin Aurlien: Implement an Esoteric Programming Language for Fun | JSConf EU 2014
Inside most of us there’s a befunge programmer who wants to come out. When doing day-to-day “serious” programming it is usually a good idea to keep them as firmly locked up as possible. Let’s ignore that instinct for a little while. In this talk I’ll try to convince you why you should try writing a completely impractical interpreter of your own. I’ll also use terms like “lexer”, “tokenizer” and “parser” at their widest possible definitions. Transcript/slides at: http://2014.jsconf.eu/speakers/arne-martin-aurlien-implement-an-esoteric-programming-language-for-fun-and-well-fun.html License: For reuse of this video under a more permissive license please get in touch with us. The speakers retain the copyright for their performances.
The computer revolution hasnt happened yet
Alan Kay's seminal 1997 OOPSLA keynote. Originally hosted on Google Video, copies of it are now only available from the squeak.org website as far as I can find. Putting it on youtube is my attempt to preserve a really important talk and computer science and computing in general.
Carnegie Mellon Professor Randy Pausch gave a lecture on Time Management at the University of Virginia in November 2007. Randy Pausch.
Evan Czaplicki - Let's be mainstream! User focused design in Elm - Curry On
Curry On Prague, July 7th 2015 http://curry-on.org http://2015.ecoop.org
In this talk will discuss the circumstances that led to Erlang, the design choices that were made, what the future holds for Erlang and how it all relates to building scalable distributed systems now. http://www.erlang-factory.com/berlin2014/robert-virding About Robert Robert Virding is Principal Language Expert at Erlang Solutions Ltd. While at Ericsson AB, Robert was one of the original members of the Ericsson Computer Science Lab, and co-inventor of the Erlang language. He took part in the original system design and contributed much of the original libraries, as well as to the current compiler. While at the lab he also did a lot of work on the implementation of logic and functional languages and on garbage collection. He has also worked as an entrepreneur and was one of the co-founders of one of the first Erlang startups (Bluetail). Robert also worked a number of years at the Swedish Defence Materiel Administration (FMV) Modelling and Simulations Group. He co-authored the first book (Prentice-Hall) on Erlang, and is regularly invited to teach and present throughout the world.
Sam Tobin-Hochstadt on Composable and Compilable Macros
Jessica Kerr "Functional Principles for Object Oriented Development"
How is an expert OO developer to improve on his craft? By learning from other paradigms! These six principles of the functional style can apply to OO. Some of these principles are part of good practice already; some express patterns both old and new; all give us different ways of thinking about problems. For developers without expertise in functional programming, examples in Java provide new techniques for writing clear, quality code.
Andrew Odlyzko: Turing and the Riemann zeta function
Andrew Odlyzko, Professor of Mathematics at the University of Minnesota, discusses "Turing and the Riemann zeta function" in a lecture given on the occasion of Princeton University's centennial celebration of Alan Turing. Learn more at www.princeton.edu/turing #turingprinceton
"Relevance of ClojureScript" by Jearvon Dharrie
Miguel Grinberg - Is Your REST API RESTful? - PyCon 2015
"Speaker: Miguel Grinberg Writing a fully complaint REST API is hard, so hard it is too common for APIs to violate one or more of the REST architectural principles. In this talk I will describe the six REST principles, and I will tell you what happens if you don't follow them. Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Inside the Python GIL.
David Beazley presentation on the Python GIL, presented at the Chicago Python User's group meeting, June, 2009. This is a mirror of the original content at http://blip.tv/carlfk/mindblowing-python-gil-2243379
Programming Well with Others: Social Skills for Geeks
Are languages, compilers, debuggers, and algorithms all you need to be a successful software engineer? In a perfect world, those who produce the best code should be the most successful. Unfortunately, we live in a world of imperfect people, and collaborating with others is at least as important as having great technical skills.
From REST to CQRS with Clojure, Kafka, & Datomic
Have you ever hit a wall with REST? Does modeling your problem domain into CRUD-able entities feel like fitting a square peg into a round hole? Have you ever tried implementing a PATCH request (without going crazy), or debated PUT vs. POST for resource updates? An alternative to CRUD-flavored REST is CQRS (Command and Query Responsibility Segregation). In this talk, I'll discuss the advantages and trade-offs of CQRS (and its cousin, Event Sourcing), and demonstrate them using an implementation of CQRS based on Clojure microservices, Kafka, and Datomic. These advantages include: Operational simplicity, flexibility, and extensibility Applying Clojure's sound model of state transitions to the resources exposed by your web application Simplified client implementation BONUS: We'll even be able to keep the best parts of REST! I'll also discuss how this technique dovetails nicely with other good ideas in the Clojure community like the design of Datomic and the ideas behind Om.Next. About the speaker: Bobby is a member of the Technology Fellows team at Capital One, where he designs and develops solutions to difficult problems, influences the technical direction of Capital One while helping development teams implement that technical direction, and engages the broader technical community via speaking and open-source contribution.
Introduction to NoSQL
Martin gives a rapid introduction to NoSQL databases: where they came from, the nature of the data models they use, and the different way you have to think about consistency. From this he outlines what kinds of circumstances you should consider using them, why they will not make relational databases obsolete, and the important consequence of polyglot persistence.
How To Shut Down Tolkien - Brandon Rhodes
While Tolkien had friends who could devise ingenious ways to critique his work without sounding critical, he had others whose remarks were merciless and direct — to the point that Tolkien simply stopped sharing new chapters as he wrote The Lord of the Rings. As programmers we share many of the struggles of writers and artists, and we often react just as badly to critique of our code. From Tolkien’s experience we will draw lessons about how to make critique generous instead of damaging, and actionable instead of personal.
pandas: Powerful data analysis tools for Python
Wes McKinney pandas is a Python library providing fast, expressive data structures for working with structured or relational data sets. In addition to being used for general purpose data manipulation and data analysis, it has also been designed to en
Implementing Languages on the BEAM
The BEAM, the Erlang VM, was designed to implement Erlang. This has led to that the features it provides and its limitations are different from most other VMs. In this talk we will why the BEAM looks like it does and how this affects the implementation of languages on it. We will also show the Erlang compiler workflow and how to use this when implementing languages. Finally we will show examples of how to "go beyond" the BEAM and implement features for which it was wasn't originally designed and the costs this can entail. About Robert: While at Ericsson AB, Robert was one of the original members of the Ericsson Computer Science Lab, and co-inventor of the Erlang language. He took part in the original system design and contributed much of the original libraries, as well as to the current compiler. While at the lab he also did a lot of work on the implementation of logic and functional languages and on garbage collection. He has also worked as an entrepreneur and was one of the co-founders of one of the first Erlang startups (Bluetail). Robert also worked a number of years at the Swedish Defence Materiel Administration (FMV) Modelling and Simulations Group. He co-authored the first book (Prentice-Hall) on Erlang, and is regularly invited to teach and present throughout the world. at present, he is the Principal Language Expert at Erlang Solutions Ltd.
Lead Designer of Scala, Martin Odersky: What's Next for Scala
Martin Odersky, the creator of Scala, talks to the SF Scala user group about what's next for Scala. A few of the topics Martin will cover include: - Commercial adoption of scala - Scala: What it was, What it is, and Where it's going - Scala Eclipse IDE - Play Framework 2.0 - Scala 2.10 ** Check out the slides at: http://mrkn.co/f/575
Paul Irish on HTML5 Boilerplate
HTML5 Boilerplate is a "rock-solid defualt for HTML5 awesome." In this video, Paul Irish, the man behind the project will show you how you can use HTML5 Boilerplate to get your projects up and running quickly while keeping best practices covered. Paul will start with an overview of HTML5 Boilerplate before diving into some examples and demos to give you a feel for how you can jumpstart your next project with HTML5 Boilerplate. ** Head over to http://marakana.com to learn more about HTML5 and open source development **
Bram Verburg - Securing Elixir Applications (ElixirConfEU 2016)
Slides and more info: http://www.elixirconf.eu/elixirconf2016/bram-verburg Every new language or framework needs time to prove itself in production, for its early adopter to try, fail, iterate, and document what they have learned. Elixir and Phoenix can leverage the 30 years head-start of the underlying Erlang platform, but for newcomers to the platform it is not always easy to find and apply Erlang best practices. This talk explores some specific security-related aspects of Elixir, Phoenix and the Erlang VM, through practical demonstrations and use-cases. Topics covered include: use of Erlang's 'ssl' module, distributed Erlang, and VM hardening against DoS attacks. Talk objectives The purpose of this talk is to make people familiar with some of the Erlang/Elixir specific security considerations. It is focussed on those things that may surprise people coming to Elixir from other languages, and therefore skims over common attack patterns (XSS, CSRF, SQLI, etc.) and their mitigations. Target audience Anyone planning to deploy an Elixir application, with or without experience in deployment/security using other languages/platforms. Bram is a system architect and security advocate at Cisco Systems. His work focusses on massively concurrent back-end systems for IoT/IoE applications, preferably built using Erlang/Elixir, as well as PKI-based security solutions for such environments. He has previously built/designed API servers using Ruby on Rails, as well as VoIP soft switches in Java.
Simplicity is Complicated
Go is often described as a simple language. It is not, it just seems that way. Rob explains how Go's simplicity hides a great deal of complexity, and that both the simplicity and complexity are part of the design.
Rich Hickey, the author of Clojure and designer of Datomic, is a software developer with over 20 years of experience in various domains. Rich has worked on scheduling systems, broadcast automation, audio analysis and fingerprinting, database design, yield management, exit poll systems, and machine listening, in a variety of languages.
Tetiana Ivanova - How to become a Data Scientist in 6 months a hacker’s approach to career planning
PyData London 2016 This talk outlines my journey from complete novice to machine learning practitioner. It started in November 2015 when I left my job as a project manager, and by April 2016 I was hired as a Data Scientist by a startup developing bleeding edge deep learning algorithms for medical imagery processing. SHORT INTRO Who I am, my background and short summary of my story. Here I will list the steps I personally took to achieve the goal I had. HOW DID I DO IT? Why I chose a “hacky” way to enter this career path. First mover advantage, why getting a degree doesn’t always improve your career prospects. Possibly a rant on the signalling function of formal education and how that is rarely aligned with a relevant practical skill set. Some stats to back it up (best career success predictors). Examples of hacking bureaucracies/social hierarchies from my experience and elsewhere. List of things not to do and common cognitive pitfalls. Networking for nerds - how to do it right. Time management for chronic procrastinators - how to plan a self-guided project. Some notes on psychology of time discounting and need for external reinforcement, with autobiographical examples. CONCLUSION You don’t need a PhD or even a masters to do machine learning. On taking calculated risks and especially calculated exits from one’s comfort zone. Some notes on soul searching and how to choose a career that is also a passion. Reading list. Slides available here: https://slack-files.com/T0LFE6T6J-F170V6945-ad054e4f6a
JVM Bytecode for Dummies (and the Rest of Us Too)
You've written applications for the JVM, using various frameworks and maybe even various languages. You understand how to rig up the CLASSPATH, get .class files to load, compile source, and set up an IDE. But you've always wanted a better understanding of the plumbing underneath. How does JVM bytecode work? How does the JVM itself work? This presentation walks you through JVM and JVM bytecode basics, with lots of examples of how to bend the JVM to your whims. Copyright © 2013 Oracle and/or its affiliates. Oracle® is a registered trademark of Oracle and/or its affiliates. All rights reserved. Oracle disclaims any warranties or representations as to the accuracy or completeness of this recording, demonstration, and/or written materials (the "Materials"). The Materials are provided "as is" without any warranty of any kind, either express or implied, including without limitation warranties of merchantability, fitness for a particular purpose, and non-infringement.
Amy Hanlon - Investigating Python Wats - PyCon 2015
"Speaker: Amy Hanlon Many of us have experienced a ""wat"" in Python - some behavior that totally mystifies us. We'll look at three areas where wats arise - identity, mutability, and scope. For each of these three topics, we'll look at some common surprising behaviors, investigate the cause of the behaviors, and cover some practical tips on how to avoid related bugs. Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Python 3 Metaprogramming
David Beazley Some of the most significant changes in Python 3 are related to metaprogramming. In this tutorial, I'll cover decorators, class decorators, descriptors, and metaclasses. However, the focus will be on idioms and examples that are only
React 2014 : Erik Meijer - What does it mean to be Reactive?
The inimitable Erik Meijer delivering his opening keynote to React 2014
CppCon 2015: Sean Parent "Better Code: Data Structures"
http://www.cppcon.org -- The standard library containers are often both misused and underused. Instead of creating new containers, applications are often structured with incidental data structures composed of objects referencing other object. This talk looks at some of the ways the standard containers can be better utilized and how creating (or using non-standard library) containers can greatly simplify code. The goal is no incidental data structures. -- Sean Parent is a principal scientist and software architect for Adobe’s mobile digital imaging group. Sean has been at Adobe since 1993 when he joined as a senior engineer working on Photoshop and later managed Adobe’s Software Technology Lab. In 2009 Sean spent a year at Google working on Chrome OS before returning to Adobe. From 1988 through 1993 Sean worked at Apple, where he was part of the system software team that developed the technologies allowing Apple’s successful transition to PowerPC. -- Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Using C++11 to speed up your Qt 5 programs Marc Mutz
Yann LeCun - The Unreasonable Effectiveness of Deep Learning
The Director of Facebook's AI Research, Dr. Yann LeCun gives a talk on deep convolutional neural networks and their applications to machine learning and computer vision (Johns Hopkins University, Center for Language and Speech Processing, 11/18/2014, Baltimore, MD)
RACify Non-Reactive Code by Dave Lee • GitHub Reactive Cocoa Developer Conference
Facebook's Dave Lee presents a talk about "RACifying" non-reactive code at the 2014 Reactive Cocoa Developer Conference hosted by GitHub. As always, feel free to leave us a comment below and don't forget to subscribe: http://bit.ly/subgithub Thanks! Connect with us. Facebook: http://fb.com/github Twitter: http://twitter.com/github Google+: http://google.com/+github LinkedIn: http://linkedin.com/company/github About GitHub GitHub is the best place to share code with friends, co-workers, classmates, and complete strangers. Millions of people use GitHub to build amazing things together. For more info, go to http://github.com
ElixirDaze 2016 - Explicit Elixir by Paul Lamb
ElixirDaze 2016 - Explicit Elixir by Paul Lamb Help us caption & translate this video! http://amara.org/v/IDDb/
(fourth RacketCon): Neil Toronto — Purely Functional 3D in Typed Racket
Efficient 3D engines use scene databases to quickly answer queries such as "What must be drawn if the viewer is here and looking this direction?" and "Return all non-opaque triangles in back-to-front order." Most 3D engines are written in an imperative style, even though most scene databases are structured as trees and operations on them can be done without destructive updates. In this talk, I give a sneak peak at a standalone 3D engine with a purely functional API, comprised mostly of combinators that operate on scene databases. I intend it to replace Plot's internal 3D engine, which draws on Cairo device contexts, but also be flexible and efficient enough to render simple game scenes using OpenGL. Neil Toronto is a recent PhD graduate from Brigham Young University, now researching programming language support for reliable mathematical computation at University of Maryland, College Park. He writes programs to draw pretty pictures in his nonexistent spare time.
Bugra Akyildiz - Outlier Detection in Time Series Signals
PyData SV 2014 Many real-world datasets have missing observations, noise and outliers; usually due to logistical problems, component failures and erroneous procedures during the data collection process. Although it is easy to avoid missing points and noise to some level, it is not easy to detect wrong measurements and outliers in the dataset. These outliers may present a larger problem in time-series signals since every data point has a temporal dependency to the data point before and after. Therefore, it is crucially important to be able to detect and possibly correct these outliers. In this talk, I will introduce three different methods to be able to detect outliers in time-series signals; Fast Fourier Transform(FFT), Median Filtering and Bayesian approach. http://bugra.github.io/work/notes/2014-03-31/outlier-detection-in-time-series-signals-fft-median-filtering/
The 100,000-student classroom
In the fall of 2011 Peter Norvig taught a class with Sebastian Thrun on artificial intelligence at Stanford attended by 175 students in situ -- and over 100,000 via an interactive webcast. He shares what he learned about teaching to a global classroom.
Open Source, Agile, and Your Brain
Andy Hunt, co-founder of The Pragmatic Programmers, LLC and a well known programmer, author, and publisher, starts the conference with his take on open source and where we're going.
Super Advanced Python
Raymond Chandler III http://pyvideo.org/video/2275/super-advanced-python https://pyohio.org/schedule/presentation/2/ In this tutorial we will touch on some of the more complex features of the Python programming language including, functional tools(filter map reduce), itertools, metaclasses, decorators and more. The Free Ohio-based Python Conference PyOhio is a free (thanks sponsors!) annual conference for Python programmers in and around Ohio and the entire Midwest. http://pyohio.org PyOhi
Scala Collections: Why Not?
Paul Phillips is a co-founder of Typesafe and the most prolific committer to Scala. He's spent the last 5 years developing the language, writing a lot of code and drawing a lot of conclusions, but has decided to walk away. In this talk, he explains why. He outlines what he believes to be certain shortcomings of the Scala collections library. In Paul's words, "Based on my extensive experience with Scala collections, I'm writing my own. The focus is much tighter: immutable, performant, predictable, correct. The talk will alternate between why the Scala collections manage none of those things, and how I hope to do better." A day after the SF Scala event, Paul left this comment on their meetup page, which seems relevant, "[...] I already discovered that if I say nothing about it then people will draw very incorrect conclusions about what the major issues are and why I've moved on. It's not sad, it's not happy, it's only a question of whether you want the real picture or some distant reflection of it." Follow along with Paul's slides: http://crcl.to/zdybs Free Scala resources: http://crcl.to/zhwdp Professional Scala training: http://crcl.to/w6kf7 Information on SF Scala: http://sfscala.org
Zandra Norman - Scaling Distributed Erlang (ElixirConfEu 2016)
Slides and more info: http://www.elixirconf.eu/elixirconf2016/zandra-norman One of the great things with Erlang is how easy it is to distribute. Distributed Erlang makes applications transparent when porting them from a single computer to multiple computers in a network. There are still areas for improvement though, and the OTP team is working on improving the scalability and services of Distributed Erlang. In this talk we'll see what plans we have for the Erlang Distribution. Talk objectives: - How Distributed Erlang works today, some issues with it and how to avoid them - The future of Distributed Erlang Target audience: - Anyone interested in building scalable applications with Elixir or Erlang Zandra is working in the Erlang/OTP team at Ericsson, and is currently focusing on improving the scalability and efficiency of Distributed Erlang. Although her Elixir experience is limited she is happy to be a part of the community and to see it grow.
Erlang Factory SF Bay 2015 - Christopher Meiklejohn - Distributed Eventually Consistent Computations
From the Lab to the Factory: Building a Production Machine Learning Infrastructure
This talk is part of Cerner's Tech Talk series. Check us out at http://engineering.cerner.com/ and @CernerEng At most companies, advanced analytics expertise is contained in a lab environment: a small team of analysts sitting at their computers and churning out reports and insights to support business decisions. But the real impact from advanced analytics comes from building models that make real-time decisions within production workflows. We will discuss how to use the ecosystem of technologies around Hadoop to support bringing models out of the lab and into the factory, with a focus on strategies for data integration, large-scale machine learning, and experimentation. About the Speaker: Josh Wills (@josh_wills) is the Senior Director of Data Science at Cloudera, a leading distrubtor of Hadoop and related services. Wills is the creator of Apache Crunch (a top level Apache project) and serves as the project's chair. Prior to Cloudera, Wills was an engineer at Google. Wills is an open source advocate and all around awesome guy.
CppCon 2015: Juan Pedro Bolívar Puente “Transducers: from Clojure to C++"
http://www.Cppcon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/cppcon/cppcon2015 — Transducers allow to express transformations on sequential inputs (like std::transform, std::filter, most of boost::range::adators  and more) in a way that is independent of the input source. They are simple high order functions agnostic of the notion of iterator or collection and can be combined by simple function composition. They can later be applied eagerly or lazily over iterators, but most interestingly, also to other kinds of "reactive" sources, like networked streams, inter-process channels or reactive observables (e.g. RxCpp ). Not only they provide an elegant decoupling between the "what" and the "how" and higher level of reuse, their implementation is often simpler and and more performant than similar boost::range adaptors. Transducers were introduced in Clojure by Rich Hickey . At Ableton we implemented them in C++ and released them as part of our Open Source modern C++ toolkit: Atria . Our implementation introduces innovations of its own, like implementing state-full transducers without mutation, enabling further safety and reusability. We also use Eric Niebler's technique  to describe and check its concepts in standard compliant C++11. In this session we will introduce the concept of transducers and how they can be implemented in modern C++. We will also cover some of the most interesting use-cases.  https://github.com/AbletonAG/atria  http://clojure.org/transducers  https://github.com/Reactive-Extensions/RxCpp  http://www.boost.org/doc/libs/1_58_0/libs/range/doc/html/range/reference/adaptors.html  http://ericniebler.com/2013/11/23/concept-checking-in-c11/ — Juanpe is a Spanish software engineer currently based in Berlin, Germany. Since 2011 he works for Ableton, where he has helped building novel musical platforms like Push and Live and where he coordinates the "Open Source Guild" helping the adoption and contribution to FLOSS. He is most experienced in C++ and Python and likes tinkering with languages like Haskell or Clojure. He is an advocate for "modern C++" and pushes for adoption of declarative and functional paradigms in the programming mainstream. He is also an open source activist and maintainer of a couple of official GNU packages like Psychosynth which introduces new realtime audio processing techniques leveraging the newest C++ standards. — Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Cliff Click - Bits of advice for VM writers - Curry On
Curry On Prague, July 7th, 2015 http://curry-on.org http://2015.ecoop.org
Juan Manuel Santos - Salting things up in the sysadmin's world
Juan Manuel Santos - Salting things up in the sysadmin's world [EuroPython 2015] [21 July 2015] [Bilbao, Euskadi, Spain] SaltStack is a thriving configuration management system written in Python that leverages YAML and Jinja2 which, by now, probably needs no introduction. This talk will cover a brief summary of why we need configuration management tools, followed by a full dive into SaltStack, its features, pros and cons, how to use it and how to extend it. By the end of this talk you will have gone from knowing little or nothing about SaltStack, to being able to deploy your own setup. This talk will be targeted to either seasoned Python developers who are taking their first steps in the system administration world, or established system administrators who secretly love Python and prefer to stay away of configuration management systems based on other languages. Its advisable that attendees have some familiarity with Python as well as with system administration concepts. Also, this presentation will be focused on GNU/Linux systems, so it is expected that attendees are comfortable with some of its concepts.
Expert to Expert: Rich Hickey and Brian Beckman - Inside Clojure
Cross posted from http://channel9.msdn.com/Shows/Going+Deep/Expert-to-Expert-Rich-Hickey-and-Brian-Beckman-Inside-Clojure. Clojure is a dynamic programming language created by Rich Hickey that targets both the Java Virtual Machine and the CLR. It is designed to be a general-purpose language, combining the approachability and interactive development of a scripting language with an efficient and robust infrastructure for multithreaded programming. Clojure is a compiled language - it compiles directly to JVM bytecode, yet remains completely dynamic. Every feature supported by Clojure is supported at runtime. Clojure provides easy access to the Java frameworks, with optional type hints and type inference, to ensure that calls to Java can avoid reflection. Clojure is a dialect of Lisp, and shares with Lisp the code-as-data philosophy and a powerful macro system. Clojure is predominantly a functional programming language, and features a rich set of immutable, persistent data structures. When mutable state is needed, Clojure offers a software transactional memory system and reactive Agent system that ensure clean, correct, multithreaded designs. Astrophysicist and Software Architect Brian Beckman interviews Rich Hickey to dig into the details of this very interesting language. If you don't know much about Clojure and the general problems it aims to solve, well, watch and listen carefully to this great conversation with plenty of whiteboarding and outstanding questions. Expert to Expert simply rocks! Thank you for spending time with us, Rich! Clojure is great!
CppCon 2014: Scott Meyers "Type Deduction and Why You Care"
http://www.cppcon.org — Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- C++98 had template type deduction, and it worked so intuitively, there was little need to understand what took place under the covers. C++11 extends type deduction to include universal references, applies it to auto variables and lambda expressions, then throws in a special auto-only deduction rule. C++14 pushes the boundary further, adding two forms of function return type deduction (auto and decltype(auto)) for arbitrary functions and offering auto parameters for lambdas. The result is that what could be treated as a black box in C++98 has become a topic that practicing C++ developers really need to understand. This talk will give you the information you need to do that. -- Scott Meyers has been working with C++ since 1988. He recently finished his new book, "Effective Modern C++". -- Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
Andrew Godwin - What can programmers learn from pilots? - PyCon 2015
"Speaker: Andrew Godwin What can Python-based software teams learn from aviation? Why should software always fail hard? What's wrong with too many error logs? And why are ops people already like pilots? Learn all this, and about planes, too. Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Raymond Hettinger - Beyond PEP 8 -- Best practices for beautiful intelligible code - PyCon 2015
"Speaker: Raymond Hettinger Distillation of knowledge gained from a decade of Python consulting, Python training, code reviews, and serving as a core developer. Learn to avoid some of the hazards of the PEP 8 style guide and learn what really matters for creating beautiful intelligible code. Slides can be found at: https://speakerdeck.com/pycon2015 and https://github.com/PyCon/2015-slides"
Introduction to SQLAlchemy
Mike Bayer The goal of the tutorial is a broad-based introduction to SQLAlchemy, spanning the Core and ORM components as well as the systems that underlie them. The tutorial takes the "harder" approach teaching from fundamentals first, emphasizing de
A Python Æsthetic: Beauty and Why I Python
Brandon Rhodes Why did I start using Python in the late 1990s? Was it for any of the reasons that I remain a fan today? In this talk we will explore how Python, even while training us to avoid and become blind to its rough edges, works to teach us ne
Pete Hunt: React: Rethinking best practices -- JSConf EU 2013
Bodil Stokke: Reactive Game Development For The Discerning Hipster [JSConf2014]
To most people in JS, functional programmers are perceived as academic hipsters raving about things like applicative functors, semigroup homomorphisms and Yoneda lemmas for no good reason except to make the rest of us feel stupid. And this is fair; there's no better way to make you feel pitifully mainstream than throwing category theory at you. Conversely, JS programmers tend to believe functional programming, therefore, can have no real world application because nobody in the real world has any idea what a Yoneda lemma is and they seem to be getting by just fine without it. Except we aren't. We've been living in callback hell for almost two decades now, and no matter how many control flow libraries we submit to npm, things don't seem to be getting any better. And that's where functional programming comes in—turns out callbacks are just functions, and those academics in their ivory towers with their Haskell compilers actually encountered and solved these problems long ago. And now we can have their solutions in JS too, because of functional reactive programming. To demonstrate, I'll attempt to write a browser based game, from scratch, with ponies, using RxJS, everybody's favourite reactive library, live on stage in 30 minutes with no callback hell in sight. And we'll be finding out if this reactive stuff is all it's cracked up to be or not. http://2014.jsconf.us/
ICFP 2014: Safe Zero-Cost Coercions for Haskell - Richard A. Eisenberg
International Conference on Functional Programming 2014. Gothenburg, Sweden.
CppCon 2014: Herb Sutter "Back to the Basics! Essentials of Modern C++ Style"
http://www.cppcon.org -- Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2014 -- This talk revisits basic questions, such as how to declare and initialize a variable, how to pass a value to a function, how to write a simple loop, and how to use smart pointers, in the light of experience with C++11 and the latest C++14 refinements. This involves examining auto, rvalue references, range-for loops, uniform initialization, lambda expressions, unique_ptr and shared_ptr, and more. -- Herb Sutter - Author, chair of the ISO C++ committee, software architect at Microsoft. -- Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
The Mother of All Demos
"The Mother of All Demos is a name given retrospectively to Douglas Engelbart's December 9, 1968, demonstration of experimental computer technologies that are now commonplace. The live demonstration featured the introduction of the computer mouse, video conferencing, teleconferencing, hypertext, word processing, hypermedia, object addressing and dynamic file linking, bootstrapping, and a collaborative real-time editor."
The Concert Programmer
Is it possible to imagine a future where “concert programmers” are as common a fixture in the worlds auditoriums as concert pianists? In this presentation Andrew will be live-coding the generative algorithms that will be producing the music that the audience will be listening too. As Andrew is typing he will also attempt to narrate the journey, discussing the various computational and musical choices made along the way. A must see for anyone interested in creative computing.
High Performance Systems in Go Lang
Go is the language of the cloud. Here's why we chose Go and how we're using it to develop high-performance systems. Help us caption & translate this video! http://amara.org/v/FG1N/
Peter Norvig - The Unreasonable Effectiveness of Data
How Billions of Trivial Data Points can Lead to Understanding Peter Norvig (Director of Research, Google) presents as part of the UBC Department of Computer Science's Distinguished Lecture Series, September 23, 2010. In decades past, models of human language were wrought from the sweat and pencils of linguists. In the modern day, it is more common to think of language modeling as an exercise in probabilistic inference from data: we observe how words and combinations of words are used, and from that build computer models of what the phrases mean. This approach is hopeless with a small amount of data, but somewhere in the range of millions or billions of examples, we pass a threshold, and the hopeless suddenly becomes effective, and computer models sometimes meet or exceed human performance. This talk gives examples of the data available in large repositories of text, images, and videos, and shows some tasks that can be accomplished with the resulting models.
DjangoCon EU 2013: Brandon Rhodes - Keynote
Videos from DjangoCon Europe 2013 are kindly provided by Heroku, a cloud application platform -- a new way of building and deploying web apps: http://heroku.com/
Brandon Rhodes - Oh, Come On Who Needs Bytearrays - PyCon 2015
Alex Sexton: Your Very Own Component Library | JSConf.ar 2014
We're all pretty big fans of Bootstrap. It's a component library that helps us turn our ideas into reality faster than we've ever been able to do in the past. Unfortunately, it's kind of bland (on purpose!), and all the sites on the internet are starting to look the same. At Stripe, we wanted the same power of being able to spin up projects quickly, but without using Bootstrap, specifically. So we made "Bootstripe". It's able to be much more opinionated, and allows lots of parallel developers to build consistent user interfaces. I'd love to tell you how to build your own, how to test it, and how to integrate it into your applications. https://jsconfar.com
Professional Software Development
We’ve come a long way in the last 20 years. We start our journey in the late 80s and our "discovery" of design principles such as The Open Closed Principle and the Liskov Substitution Principle. In the middle 90s, we discovered that these principle led to repeating patterns of design. We gave those patterns names such as Visitor and Decorator. At the turn of the millennium we found that the benefits gained from the principles and patterns could be amplified by combining them with practices such as Test Driven Development and Continuous Integration. And now, as the decade is coming to a close, we have found that these principles, patterns, and practices have driven us to define a true profession. What will that profession require of us, and who among us can truly claim to be professional?