Monday, 7th - Tuesday, 8th December in Online Event

38 experts spoke.
Overview

YOW! Conference is designed by developers for developers, and each speaker has been invited because of their development expertise by our independent international program committee. At YOW! Conference you'll get straight tech talk by world-class experts and networking with like-minded developers.

Excited? Share it!

Programme

Autonomy & Asynchrony: The Key to Designing Reliable Systems

The real world, with all its complexity, can at the same time be simple, elegant and beautiful. It thrives on autonomy and asynchrony, the two most important things that bring order to chaos. The real world does not pause for something to complete before moving on. And yet, when we write software, “Command and Control” is the norm. We find clever ways of doing this while keeping up with all the new technologies and the languages in fashion, all the while ignoring the realities of life.

In this session, explore an alternate universe in which Event Driven Architecture can power even the most complex mission-critical systems. Learn how communicating asynchronously via events leads to building systems that are autonomous and much more reliable. Embrace asynchrony and autonomy. Make the complex simple.



Indu Alagarsamy

Indu Alagarsamy has over 15 years of experience in the software industry.


Adaptive Security

As humans we process information as it is presented to us. We use the information presented to us to decide on how to react and possibly adapt to the current situation. This trait has a lot of advantages and has served us well over many years. Our approach to the security of our systems should be much the same. Join Aaron as he introduces patterns for processing potentially malicious activity and weaving an adaptive security system.



Aaron Bedra

Aaron Bedra has served as a Chief Security Officer, Chief Technology Officer, Chief Scientist and Principal Engineer/Architect. He currently works at the intersection of trading + technology as a senior software engineer at DRW.

Aaron has worked professionally on programming languages, most notably Clojure and ClojureScript. He is the creator of Repsheet, an open source threat intelligence toolkit; is the co-author of Programming Clojure, 2nd and 3rd Edition and a contributor to Functional Programming: A PragPub Anthology.

Aaron blogs about software and security at aaronbedra.com


DevOps @ Wotif: Making Easy = Right

We know the “right thing” to do is to work together, to remove bottlenecks, to automate, automate, automate. But when the status quo is finger-pointing, mistrust, blame, and over-exhaustion from increasingly complex manual releases, it seems impossible to find a way to climb out of the downward spiral. How did an IT department turn this around to become a harmonious department with common goals and over 10x faster cycle times?

Winning the hearts and minds needed for lasting DevOps change requires something more than just great automation. This is the story of how Wotif found a way to incentivise a DevOps transformation across an entire IT department, resulting in cycle times measured in hours instead of weeks/months. While this journey involved technology such as DropWizard, Puppet & ZooKeeper, Matt (dev) and Alexandra (ops) extract principles that they hope can be applied to any organisation at grassroots and leadership levels using existing toolchains to support not only the best ideas of the present but also the legacy of the past and the unknown innovation of the future.



Matt Callanan

Senior Software Development Engineer
Expedia Group


It’s Complicated…

What does it mean to be complicated? How can we manage complexity when we scale up systems? Why do people find it horrifying when the internal complexity of monolithic apps is replaced by a “death star” diagram of the relationships between microservices? Why do people expect complex adaptive systems to behave predictably? How does complicated relate to intuitive? Why is one of the most complicated things we own, our smartphone, easy to use by 2 year olds?



Adrian Cockcroft

Adrian Cockcroft has had a long career working at the leading edge of technology, and is fascinated by what happens next. In his new role as VP Sustainability Architecture at Amazon he is developing and sharing best practices for sustainable product architectures, and working with teams across AWS to support their own sustainability programs.


Production Haskell

Haskell has recently begun seeing more production use, as tooling has improved dramatically (no more Cabal hell), and the language features are particularly well-suited to the problems challenging many organizations (i.e. concurrency and multi-core scalability). In this talk, we’ll see how Helium, a startup using Haskell, builds, deploys, monitors, tests, and writes Haskell in production.



Reid Draper

Sr. Software Engineer
Helium


Transcript: End-User Programming Of Social Apps

Say you have started a book club. You need to coordinate with the members to choose books to read, schedule meetings, decide who is bringing the wine and cheese, etc. You probably use some spreadsheets, some web services like message forums and polls — and make it all work with a flood of email. You watch your life passing by as you robotically copy and paste between email and spreadsheets and all these services. What you want is a custom website like a Rails app or a Drupal installation, but you were an English major. What you need is a tool as easy to learn as a spreadsheet or HyperCard, but one designed to build ad-hoc social applications. Of course it should be at home on the dominant platform for social software: phones.

Transcript takes the vision of end-user programming as in HyperCard and reimagines it on the phone, designed to do the things you want to do with a phone: mediate and structure conversations. The experience is more like editing a document than programming, but hidden inside this Trojan Horse is a highly distilled yet fully capable programming language. I will demo an early prototype of Transcript and discuss our vision of bringing programming to everyone.



Jonathan Edwards

Member
SAP CDG Labs


The Pathologies of Big “Messy” Data in Telco

In this talk, Jay will share his experiences of dealing with the realities of telecoms data at scale. The tools he uses are broadly applicable outside of the domain.

Modern networks are today still being managed with tools that were built over a decade ago. It sounds crazy, but it’s true.

Nowhere is this more ludicrous than in the world of telecoms operators, where Big Data was all but invented. The technologies coming out of the social- and web-scale space are all well-and-good when the data is well formed, and understood, and where the organisation is relatively flat. But in telco, it’s a different world.

ITIL, eTOM and the Common Information Model whilst widely adopted, have done nothing to improve the realities of dealing with the typical data found in the telecoms domain. It’s messy, voluminous, fragmented, duplicated, and at times seems almost purposefully obfuscated! As our networks get larger, as access technologies proliferate, as the products get more complex and the accumulated cruft of legacy products takes a long time to shake off, the way we manage network telemetry pipelines and the data that makes sense of it simply must evolve.

In this talk, Jay will share his experiences spanning Splunk® and it’s Unix Pipe Philosophy “SPL” language, coupled with Titan, and several other tools and technologies to make sense of that data and unravel the mess, at scale.



Jay Fenton

Jay Fenton is a serial entrepreneur, developer and all-round technologist.


Using Formal Methods to Eliminate Exploitable Bugs

For decades, formal methods have offered the promise of software that doesn’t have exploitable bugs. Until recently, however, it hasn’t been possible to verify software of sufficient complexity to be useful. Recently, that situation has changed. SeL4 is an open-source operating system microkernel efficient enough to be used in a wide range of practical applications. It has been proven to be fully functionally correct, ensuring the absence of buffer overflows, null pointer exceptions, use-after-free errors, etc., and to enforce integrity and confidentiality properties. The CompCert Verifying C Compiler maps source C programs to provably equivalent assembly language, ensuring the absence of exploitable bugs in the compiler. A number of factors have enabled this revolution in the formal methods community, including increased processor speed, better infrastructure like the Isabelle/HOL and Coq theorem provers, specialized logics for reasoning about low-level code, increasing levels of automation afforded by tactic languages and SAT/SMT solvers, and the decision to move away from trying to verify existing artifacts and instead focus on co-developing the code and the correctness proof. In this talk, I will explore the promise and limitations of current formal methods techniques for producing useful software that probably does not contain exploitable bugs. I will discuss these issues in the context of DARPA’s HACMS program, which has as its goal the creation of high-assurance software for vehicles, including quad-copters, helicopters, and automobiles.



Kathleen Fisher

Professor
Tufts


Writing a Writer

Imagine you are programming right now. Let that image sink in. What are you programming?

For the past two years I’ve been writing a program that manipulates language like a poet. In doing this I am using the software as an instrument to understand how writers think. I am programming it in Common Lisp. The output of that program has been judged master-level poetry by an expert audience. In this talk I’ll tell you how my program works and how it’s programmed. I suspect the programming I do is not like the programming you do.



Richard P Gabriel

Researcher
IBM Research


Always Keep a Benchmark in your Back Pocket

As programmers we all know about the importance of test suites but tend to leave creating a benchmark – either to measure against other software solutions, or to compare hardware choices – until the last minute. That can lead to a hardware choice made on too few criteria, having to react to a competing shiny solution on their ground, or simply continuing with your own ””new features”” when they should be taken behind the woodshed.

This can determine your work environment and team membership for years. I will discuss ways to avoid being caught out, and the importance of taking the time to prepare in advance.



Simon Garland

Chief Strategist
Kx’s


A Day in the Life of a Netflix Engineer

Netflix is a large and ever-changing ecosystem made up of:

  • hundreds of production changes every hour,
  • thousands of micro services,
  • tens of thousands of instances,
  • millions of concurrent customers
  • billions of metrics every minute.

This is an in-the-trenches look at what operating at Netflix scale is really like. It covers how Netflix views the velocity of innovation, expected failures, high availability, engineer responsibility, and obsessing over the quality of the customer experience. It also explains why freedom and responsibility are key, trust is required, and chaos is your friend.



Dave Hahn

Sr. Engineer Critical Operations & Reliability
Netflix


Building Microservice Architectures in Go

Moving to a microservice architecture and embracing a cloud native approach is a complex challenge, which often requires re-evaluating our approach to technology. Having previously helped transition Hailo to a new microservice platform, built almost entirely in Go, Matt leverages modern technologies and a microservice based approach to build reliable platforms which can scale to millions of users. This talk will cover how to develop and migrate to a microservice based architecture using Go, common pitfalls to avoid, and lessons learnt when developing high volume, low latency, distributed applications.



Matt Heath

Matt is a senior engineer at Monzo — the UKs fastest growing bank — where he's spent the last few years building the platform and payment systems that underpin the Monzo experience.


Making Hacking Child’s Play

How does it keep happening? I mean why are websites so consistently hacked? Is it the work of sophisticated cyber-villains operating from underground lairs? As it turns out, many of today’s online attacks are mounted by kids – legally children – who simply have time, patience and access to Google.

In this session, we’re going to look at and execute a heap of online attacks with tools that even kids can use. You’ll learn just how easy it is to mount these attacks and most importantly, what it is you need to do to keep your apps secure not just from mischievous kids, but from cyber-criminals and even nation-state actors.

This talk is scary, entertaining and will make you distrusting of any kid with a PC.



Troy Hunt

Troy is a Microsoft Regional Director and MVP, Pluralsight author and world-renowned internet security specialist. He spends his time teaching developers how to break into their own systems before helping to piece them back together to be secure against today’s online threats. He’s also the creator of “Have I been pwned?”, the free online service for breach monitoring and notifications. Troy regularly blogs at troyhunt.com from his home in Australia.


Frugal Innovation and Scaffolding Software

Even when located in one of the largest cities on the continent of Africa, we still face many challenges when building software: lack of electricity, little to no connectivity particularly in rural areas, cash-based transactions, lack of an address system, and more. But out of these constraints come creative and innovative ways to address these unique challenges … and with it some frugal software innovation you might want to hear about.



Betty Enyonam Kumahor

Founder
The Cobalt Partners


Property Based Testing : Shrinking Risk In Your Code

Perhaps you’ve been hearing a lot about Haskell programmers being absolutely certain that their code is correct but you haven’t taken the leap into day to day Haskell development. Do not despair, there are techniques that can allow you to have confidence in your code without needing to change your development stack. In fact, you can use the same testing techniques Haskellers use without even using a language with a static type checker.

In this session we will be looking at Property Based Testing, and how this approach can allow us to avoid thousands of lines of testing code when ensuring that our code meets specification. Property Based Testing generates inputs based on the properties of the program that we stipulate, and so are based on the business logic, in the same way that types are. Furthermore, if the test fails, a good framework will shrink the problem to the smallest possible data set that gives an error, helping to pinpoint the bug. This session requires no previous knowledge of free-monads, co-products, or other terms you may have grown to hate.



Amanda Laucher

Amanda Laucher is currently working with Neo Technology, the company behind Neo4j. She is a language geek who is often found ranting about functional languages and great type systems.


Microservices – Building Software that is #neverdone

The software industry is changing faster than ever. Now, with microservices becoming more and more accepted as an approach to systems architecture, the rate of change of our industry and of the software we write is getting faster and faster.

In this talk, James explores what this means for developers writing code now. Do we abandon our quest to build quality in? What does it mean for design if we are building software explicitly to throw it away a short time later. Is TDD dead? What does software craftsmanship look like through the lens of replaceable code in small replaceable services?

In short, what does it mean if we are #neverdone?



James Lewis

Director Thoughtworks Inc


Mobile Performance at Facebook

Facebook moves fast on mobile, shipping the mobile application at least twice a month to hundreds of millions of diverse devices. We also want to make sure the application is fast, as this is a primary ingredient in a delightful user experience. This talk walks through how Facebook thinks about performance as a feature, how it measures success, and deep dives in to the tools we’ve built to improve performance, prevent regressions and enable an amazing experience for everyone.



Mike Magruder

Software Engineer
Facebook


The Mother of all Programming Languages Demos

Engelbart’s demo in 1968 put forth compelling visions for personal computing that led to almost 30 years of innovation. Can we do the same for programming languages today? This presentation introduces several new PL technologies to this end. Type-less eliminates most type annotations from object-oriented code so programmers can get rich code completion with much less overhead. Glitch manages state and time like a garbage collector manages memory to achieve React-style reactivity that also applies to side effects and multi-core executions! Glitch can also update executing programs according to live code edits, allowing for a rich live programming experience. Together, Type-less and Glitch lead to a novel feedback-rich programmer experience that is demonstrated in the presentation.



Sean Mcdirmid

Researcher
Microsoft Research Asia


Using Docker Safely

The security of containers has been a hotly discussed topic. This talk will explain the main concerns around container security, and offer some best practices and guidance for addressing them. The guiding philosophy is “defense in depth”; no one layer or tool should be relied upon to provide complete security.

The topics covered will include:

  • The isolation guarantees of containers
  • Using Content Trust to make sure your images haven’t been tampered with
  • How to limit the resources that containers can access
  • How to audit and monitor containers
  • Using VMs and containers together to maximise security and efficiency
  • How to safely share secrets (API keys, passwords) with containers


Adrian Mouat

Adrian Mouat is Chief Scientist at Container Solutions, a European services company specialising in container technologies. He is currently researching container orchestration platforms and image management. Adrian authored "Using Docker" for O'Reilly publishing and is a member of the Docker Captains program.


Deploying and Scaling Microservices

The challenges of managing many, smaller deployable services mean that what we need in terms of deployment platforms are very different to what was needed before. But few areas of software technology have been experiencing as much innovation and churn as the deployment options available for microservice architectures. From appication containers, to docker, to mesos and beyond, this talk will break apart the myriad challenges that can come from managing microservices at scale, and how to pick the right technologies for you.



Sam Newman

Sam Newman, a techie interested in cloud, continuous delivery and microservices. Aside from other things he's committed sporadically to open source projects, spoke at more than a few conferences, and wrote some things including the book Building Microservices for O'Reilly.


Engineering and Exploring the Red Planet

On August 5th 2012, NASA landed its most capable robotic geologist on the surface of the Red Planet. The Mars Science Laboratory (MSL) mission landed a 2000lb rover, the size of a compact car, to explore the planes of Mars. The rover, aptly named Curiosity, will search for organic compounds, characterize the climate and geology, and continue the search for life. One of the most challenging aspects of the mission, from an engineering perspective, was safely landing the rover on the surface. The entry descent and landing (EDL) system used a heat shield to accommodate its hypersonic entry conditions, followed by a supersonic parachute, and eight retro rockets for the powered descent phase. For its final terminal descent, a maneuver called the sky crane was used where the rover was lowered on tethers for touchdown. The talk will describe the motivation for Mars Exploration and how the MSL EDL engineering challenges were tackled with computational modeling and cutting edge experimental techniques.



Kamal Oudrhiri

President
Grove of Hope


Designing for Failure: Scaling Uber’s Backend by Breaking Everything

As Uber scales its business to new products in new cities, the requirements for high availability and scalability increase. As the engineering team scales, doubling every 6 months, the challenges of building a reliable system grow with it. At our current scale, even brief outages in the service are very costly, both in dollars to the company and with real world impact on people’s lives.

To get better at handling failure and design for it, we’ve had to make failures more common. Every new system that we build is subjected to regular failure testing, even databases. This requires some new technology choices from the more comfortable ones that worked when we were smaller.

The shift from a smaller service with a few hardened components to a global operation with hundreds of services is as much cultural as it is technical. This talk will cover the Uber architecture and how it handles every failure we can think of. It’ll also cover some real outages and how they’ve influenced our new design.



Matt Ranney

Sr. Staff Engineer
Uber


Thriving in a Stochastic World

Modern software developers have abandoned waterfall processes and embraced agile and lean methods. Yet, the waterfall process has left behind a dangerous legacy, one that stealthily controls our behavior. Developers act as if uncertainty is intrinsically bad, and predictability is intrinsically good. Consequently, they strive to eliminate as much variability as possible in schedule, performance, and cost. And, although they never use the term, they deeply value determinism. In this presentation, Don Reinertsen will present an alternative view. How could we design development processes such that variability improves economic outcomes rather than hurting them? When we seek to thrive in a stochastic world, rather than merely survive in it, we look at things quite differently.



Don Reinertsen

Consultant & Author
Reinertsen & Associates


Rethinking MVC with React Native & ReactiveCocoa

Traditional event-based MVC has been the standard pattern for building user interfaces for decades. However, this pattern has its downsides – specifically, shared mutable state and cascading event chains can lead to code that is difficult to comprehend and reason about.

In this talk we’ll look at alternative approaches that leverage functional programming techniques, using the native mobile app development space to demonstrate. We’ll start by introducing the concepts of declarative UIs and reactive one-way data flow, as exemplified by the JavaScript-based React Native framework. Then, if JavaScript is not your cup of tea, we’ll see how we can apply the same principles using Swift and ReactiveCocoa, a functional reactive programming library for Cocoa.

Irrespective of what language you use or what sort of user interfaces you build, this talk will introduce you to the virtues of reactive one-way data flow and immutable state, and how they can help you write code that is easier to understand.



Sam Ritchie

Chief Codesplicer
Codesplice


Past, Present and Future of Java

In 2015 Java celebrates 20 years as a generally available programming language and platform. This session will cover some of the highlights, challenges, and insights gleaned of Java’s rise from newcomer to solid performer. We’ll take a look at where the technology is today, and peek into the crystal ball to explore some interesting directions that the technology may take us over the next 20 years.



Georges Saab

VP Engineering
Oracle


Engineering and Exploring the Red Planet

On August 5th 2012, NASA landed its most capable robotic geologist on the surface of the Red Planet. The Mars Science Laboratory (MSL) mission landed a 2000lb rover, the size of a compact car, to explore the planes of Mars. The rover, aptly named Curiosity, will search for organic compounds, characterize the climate and geology, and continue the search for life. One of the most challenging aspects of the mission, from an engineering perspective, was safely landing the rover on the surface. The entry descent and landing (EDL) system used a heat shield to accommodate its hypersonic entry conditions, followed by a supersonic parachute, and eight retro rockets for the powered descent phase. For its final terminal descent, a maneuver called the sky crane was used where the rover was lowered on tethers for touchdown. The talk will describe the motivation for Mars Exploration and how the MSL EDL engineering challenges were tackled with computational modeling and cutting edge experimental techniques.



Anita Sengupta

Rocket Scientist, Sr. Vice President
University of Southern California


Pragmatic Microservices: Whether, When and How to Migrate

One of the most powerful trends in software today is building large systems out of composable microservices, often deployed in containers. Many large-scale web companies have migrated over time to this architecture – and for good reason. But, as with any powerful technique, microservices come with their own brand of tradeoffs, and it is important to be aware of them before deciding whether they are appropriate in any particular case. They are not for every scale of problem, for every stage of company, or for every team.

This session takes a pragmatic approach to microservices, and compares them to the alternatives at different stages of company evolution. Using examples both from Google and eBay as well as smaller organizations, it makes practical suggestions about whether, when, and how an organization should consider migrating. Assuming migration is the appropriate choice, it outlines an experience-based, incremental approach to making such a rearchitecture successful.



Randy Shoup

VP Engineering and Chief Architect at eBay


40 Agile Methods in 40 Minutes

With 73% of the world using Scrum as their predominant Agile method, this session will open up your eyes to the many other Agile and edgy Agile methods and movements in the world today For many, Agile is a toolbox of potential methods, practices and techniques, and like any good toolbox it is often more about using the right tool for the problem that will result in meaningful results.Take a rapid journey into the world of methods like Mikado, Nonban, Vanguard and movements like Holocracy,Drive and Stoos where we will uncover 40 methods and movements in 40 minutes to help strengthen your toolbox.



Craig Smith

Director
YOW! Conference


DevOps @ Wotif: Making Easy = Right

We know the “right thing” to do is to work together, to remove bottlenecks, to automate, automate, automate. But when the status quo is finger-pointing, mistrust, blame, and over-exhaustion from increasingly complex manual releases, it seems impossible to find a way to climb out of the downward spiral. How did an IT department turn this around to become a harmonious department with common goals and over 10x faster cycle times?

Winning the hearts and minds needed for lasting DevOps change requires something more than just great automation. This is the story of how Wotif found a way to incentivise a DevOps transformation across an entire IT department, resulting in cycle times measured in hours instead of weeks/months. While this journey involved technology such as DropWizard, Puppet & ZooKeeper, Matt (dev) and Alexandra (ops) extract principles that they hope can be applied to any organisation at grassroots and leadership levels using existing toolchains to support not only the best ideas of the present but also the legacy of the past and the unknown innovation of the future.



Alexandra Spillane

Sr. System Administrator
Wotif & Expedia


The Miracle of Generators

The ECMAScript 2015 specification introduced iterators, which generalize iteration over common data structures, as well as providing an interface for allowing you to iterate over any custom data structures using common language constructs. ES2015 also introduced generator functions, which make writing arbitrary iterators a lot easier and less boilerplatey.

But generators aren’t just for making simple iterators over data structures. Because they’re bidirectional—they don’t only produce output, they can also take input—they’re actually coroutines, which means there’s no end to the sort of fun you can apply them to. We’re going to explore how we can use them to make asynchronous programming in JavaScript a lot more elegant—to chart a path out of callback hell. And then we’re going to take a look at what we’ve really discovered: one of the most fearsome mysteries of computer science, suddenly laid bare before us.



Bodil Stokke

Bodil works as a computer science researcher for a secretive think tank, and is a world renowned expert in varied fields such as pizza and persistent data structures. Contrary to popular rumour, she only has five fingers on each hand, but is still an Emacs user.


Rethinking MVC with React Native & ReactiveCocoa

Traditional event-based MVC has been the standard pattern for building user interfaces for decades. However, this pattern has its downsides – specifically, shared mutable state and cascading event chains can lead to code that is difficult to comprehend and reason about.

In this talk we’ll look at alternative approaches that leverage functional programming techniques, using the native mobile app development space to demonstrate. We’ll start by introducing the concepts of declarative UIs and reactive one-way data flow, as exemplified by the JavaScript-based React Native framework. Then, if JavaScript is not your cup of tea, we’ll see how we can apply the same principles using Swift and ReactiveCocoa, a functional reactive programming library for Cocoa.

Irrespective of what language you use or what sort of user interfaces you build, this talk will introduce you to the virtues of reactive one-way data flow and immutable state, and how they can help you write code that is easier to understand.



Ben Teese

Sr. Software Engineer
Shine Solutions


Delivery Mapping: Turning the Lights On

It seems the hot topic of the moment is how to “solve” agile delivery at scale. Whether it be the heavyweights of SAFe, DAD and LeSS, or upstarts like Reliable Scrum, the pitch is the same: Our solution, along with its associated consulting and certification, is the Ultimate Answer.

As Deep Thought explains in The Hitchhikers’ Guide to the Galaxy: “I think the problem, to be quite honest with you, is that you’ve never actually known what the question is.”

Different organisations have different needs, challenges and expectations, so Dan thinks the first step on any scaling journey is to get a sense of where you really are. He proposes a three stage approach which starts with turning on the lights to see what’s hiding in the dark. This is often trickier than it looks, and involves tigers, dragons and wild-assed guesses.

Come along and learn new buzzwords like Demand Mapping and Skills Liquidity, and maybe learn why it is dangerous to start with the solution already in mind.



Daniel Terhorst-North

Daniel Terhorst-North uses his deep technical and organisational knowledge to help CIOs, business and software teams to deliver quickly and successfully. He puts people first and finds simple, pragmatic solutions to business and technical problems, often using lean and agile techniques. With over thirty years of experience in IT, Daniel is a frequent speaker at technology and business conferences worldwide.


Rigor Mortis (Avoiding)

In this talk I dig into the Elixir language—a functional language, inspired in part by the philosophy of Ruby, that runs on the Erlang VM. This isn’t a sales pitch for Elixir—there are dozens of great languages out there. Instead, I want to talk about how learning Elixir has changed the way I think about programming. And I want to encourage you to invest in your futures by developing new vocabularies and new reflexes.

My goal? To save your career and make your life interesting.



Dave Thomas

Dave is a freelance F# engineer and a Microsoft MVP, formerly with Xamarin.


Play in C#

C# is evolving rapidly on all fronts. Runtime, libraries and IDE support show up on new platforms. The language itself has added many smaller features recently, and we are looking at much bolder steps for the next version. The “Roslyn” language engine offers real time access to syntactic and semantic information about source code and has a public API for anyone’s static analysis tools, IDE extensions and scripting environments to freely tap into. This whole gigantic playground is open source for everyone to tinker with and contribute to. Even if you don’t play in C# in your daily life, don’t be shy: put on your curly braces and come join us in a swing!



Mads Torgersen

Mads Torgersen is the language PM for C# at Microsoft, where he runs the C# language design process and maintains the language specification. He is also on the design team for TypeScript and Visual Basic, and he contributes to the Roslyn project, which has reinvented the C# and VB compilers and taken them open source.

Many years ago Mads was a professor, and also contributed to a language starting with J.


The Future of Software Engineering

Through its first 40 years, the field of “Software Engineering” produced little that was useful to the software practitioner. That has led to a very peculiar situation: we have a field where the set of practices referred to as “engineering” simply doesn’t work well, and are deliberately avoided by the vast majority of skilled practitioners in the field. (The situation is odd because, in other fields, the term “engineering” is reserved for practices that lead to success.) As a result, the idea is spreading that perhaps software development is simply incompatible with engineering; that software developers are not, and never will be, real engineers.

I believe that any field that mass-produces useful artifacts for people must take its practices seriously, and must approach them with an engineer’s sense of responsibility. It’s time to take a fresh look at what that really should mean for our field. With an extra 45 years of experience about the task of programming, and a broad survey of the varied different engineering disciplines, can we envision a future for a field of “software engineering” that is worthy of the name?



Glenn Vanderburg

Sr. Director
LivingSocial


Scala and the JVM as a Big Data Platform: Lessons from the Spark Project

Apache Spark is implemented in Scala and it’s user-facing Scala API is very similar to Scala’s own collections API. The power and concision of this API are bringing many developers to Scala.

On the other hand, while the JVM is an excellent, general-purpose platform for scalable computing, its management of objects is suboptimal for high-performance data crunching. Hence, the Spark project has recently started a project called ””Tungsten”” to build internal optimizations based on custom data layouts, manual memory management (both on-heap and off-heap), etc.

Using these and other examples from the Spark project, this talk discusses the strengths and weaknesses of Scala and the JVM for Big Data.



Dean Wampler

Dean Wampler, Ph.D., is the Architect for Big Data Products and Services in the Office of the CTO at Lightbend, where he focuses on the evolving “Fast Data” ecosystem for streaming applications based on the SMACK stack, Spark, Mesos, Akka (and the rest of the Lightbend Reactive Platform), Cassandra, Kafka, and other tools.


Facebook’s Product Infrastructure

Modern software can only be built in terms of existing software. The roots of programs we use every day stretch back to the earliest days of computing. Like all infrastructure, the value of this shared structure as a supply chain, and as a conceptual framework, is tremendous. Facebook explicitly takes advantage of these economies by employing “The Hacker Way,” which favors quick, loosely coupled iterations based on existing solutions, over extensive planning and coordination. We have demonstrated that this is a remarkably effective way to develop and improve our products.

At the same time, the requirements for our software products change more quickly than our software environments. Mismatches between product features and the infrastructure we build them on gives rise to bloat and inefficiency in our applications over the long-term. Facebook’s product infrastructure is intended to plug these gaps in order to help product teams to move faster, without sacrificing too much in efficiency or performance.

The most recent shift from a golden age of web-delivered desktop software, to the brave new world of mobile development, has widened many of these gaps, creating room for Facebook projects like React Native, GraphQL and Relay to deliver significant value. This talk will explore some general ideas about how we develop product infrastructure at Facebook, and also how these specific technologies fit together and what that implies about the next generation of mobile infrastructure.



Adam Wolff

Engineering Director
Facebook


Sustainability Supporting Data Variability: Keeping Core Components Clean while Dealing with Data Variability

A big challenge in building complex, data-intensive systems is how to sustainably support data variation along with schema and feature evolution. This talk examines strategies, practices, and patterns drawn from real experiences that support new and evolving data-processing requirements while keeping the core architecture clean. As complex systems evolve to meet varying data formats, they can devolve into poorly architected Big Balls of Mud filled with special-case logic and one-off processing. Alternatively, you can isolate core components of your system and protect them from entanglements and unnecessary complexity by designing them to operate on common data formats while providing extension mechanisms that enable processing variations.



Joseph Yoder

Founder
Refactory


SkillsCasts

Hold tight, skillscasts coming soon!

 

Other Years