This page contains classes, lectures, and tutorials about various computer programming languages. The technology lectures and classes provide a great way to pick up some new knowledge about your programming language of choice.
Google's Python Class and Google's C++ Class
Here are the complete Introductory Python and C++ programming classes taught at Google! The classes are geared for people with very little programming experience. Content provided includes writen materials, lecture videos, and coding exercises.
Following are videotaped lectures on programming-related technology areas. These lectures provide opportuities for students and faculty to learn directly from expert develop and can be used as "guest lectures" to accompany traditional programming courses.
C++
Java
JavaScript
Python
Go
Presenter: Lawrence Crowl
The next C++ standard will provide direct support for threads, including a model of memory, atomics, variables, launching, scheduling, synchronization, and termination. This talk will present the current threading model and outline the remaining work.
Presenter: Lawrence Crowl
The upcoming C++ standard will have many new features, several major and many minor. The major features are concurrency, template concepts, move semantics, generalized constant expressions, automatic variable typing, and garbage collection. We will present an overview of the major features and breeze through a list of other features, commenting on their likeliness to make the standard.
Presenter: Kevlin Henney
Both by accident and by design, C++ supports a number of different styles and approaches to programming. Its evolution from C gives it obvious support for a procedural systems programming style based on C idioms, but past, present and future language support opens up a wealth of other approaches and idioms, including object-oriented programming, generic programming and some elements of functional programming.
This diversity is both a strength and a weakness. It can lead to code that is crisp and well matched to its problem. But it can also lead to code that is at best considered an exercise in groundless post-modernism or, less favorably, an unmaintainable and incoherent mess.
This talk examines some of the styles and approaches, including their key strengths and accidental complexities, as well as consequences of and techniques for combining them.
Presenter: Jeremy Manson
This talk describes the Java Memory Model and how it affects the ways concurrent software should be written. Recent changes to the memory model, which were incorporated into JDK 5, redefined the semantics of threads, synchronization, volatile variables, and final fields. The new memory model provides efficient and provably correct techniques for safely and correctly implementing concurrent operations. These techniques are compatible with existing good programming practice, although care needs to be taken in a couple of corner cases.
Most programmers can avoid depending on low-level details and instead just use the high-level concurrency abstractions provided in the new concurrency libraries. However, for those who have to write their own concurrency abstractions, understanding the building blocks of concurrency can be vitally important.
This talk provides a simple and clear definition of what synchronization actually does, defines the semantics of volatile variables and the java.util.concurrent.atomic package (and how they can be used to create efficient concurrent implementations), and describes how final fields can be used to provide thread-safe immutable objects without synchronization.
Presenter: Alex Aiken
This talk presents a novel approach to detecting races in concurrent Java programs. The approach is sound in that it detects all races and is precise in that it misidentifies few non-races as races. The approach is also effective, finding tens to hundreds of serious and previously unknown synchronization bugs in real-world programs.
Presenters: Josh Bloch and William Pugh
Java Puzzlers, Episode VI: The Phantom-Reference Menace/Attack of the Clone/Revenge of the Shift. Josh Bloch and special guest star Bill Pugh present yet another installment in the continuing saga of Java Puzzlers, consisting of eight more programming puzzles for your entertainment and enlightenment. The game show format keeps you on your toes while the puzzles teach you about the subtleties of the Java programming language and its core libraries. Anyone with a working knowledge of the language will be able to understand the puzzles, but even the most seasoned veterans will be challenged.
Presenter: Douglas Crockford
JavaScript is a language with more than its share of bad parts. It went from non-existence to global adoption in an alarmingly short period of time. It never had an interval in the lab when it could be tried out and polished. JavaScript has some extraordinarily good parts. In JavaScript there is a beautiful, highly expressive language that is buried under a steaming pile of good intentions and blunders. The best nature of JavaScript was so effectively hidden that for many years the prevailing opinion of JavaScript was that it was an unsightly, incompetent abomination. This session will expose the goodness in JavaScript, an outstanding dynamic programming language. Within the language is an elegant subset that is vastly superior to the language as a whole, being more reliable, readable and maintainable.
Presenter: Nicholas C. Zakas
As an interpreted language, JavaScript is filled with hidden performance issues that conspire to slow down your code and ruin the user experience. Learn exactly what is fast, what is slow, and what you can do to squeeze that last bit of performance out of your JavaScript code.
Presenter: Thomas Wouters
The Python language, while object-oriented, is fundamentally different from both C++ and Java. The dynamic and introspective nature of Python allow for language mechanics unlike that of static languages. This talk aims to enlighten programmers new to Python about these fundamentals, the language mechanics that flow from them and how to effectively put those to use. Among the topics covered are duck-typing, interfaces, descriptors, decorators, metaclasses, reference-counting and the cyclic-garbage collector, the divide between C/C++ data and Python objects and the CPython implementation in general.
Presenter:Alex Martelli
Design Patterns must be studied in the context on the language in which they'll get implemented (the Gang of Four made that point very strongly in their book, though almost everybody else seems not to have noticed). This talk explores several categories of classic "elementary" DPs in a Python context -- Creational, Masquerading, Adaptation, and Template.
Presenter: Alex Martelli
This talk explores several categories of classic "elementary" design patterns in a Python context -- Creational, Masquerading, Adaptation, and Template.
Presenter: Guido Van Rossum
Since the renewed Python 3000 effort was announced at PyCon 2006, a lot has happened. We've implemented about half of the promised changes in a branch, we've solidified the schedule, there's a refactoring tool that can do source-to-source translations, and we've produced several gigabytes of discussion about language change proposals (most of which were deemed too radical in the end). In this talk, a preview of a keynote to be given at PyCon 2007, I'll discuss the Python 3000 road map, status, and what this means for the average Python user.
resenter: Alex Martelli
Google Tech Talk from October 26, 2005 on the Python Object Model.
Presenter: Alex Martelli
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.
Presenter: Rob Pike
Go is a new experimental systems programming language intended to make software development fast. Our goal is that a major Google binary should be buildable in a few seconds on a single machine. The language is concurrent, garbage-collected, and requires explicit declaration of dependencies. Simple syntax and a clean type system support a number of programming styles.