J On The Beach
"Big Data in the Business";
"DevOps & Infrastructures";
"Embedded & IoT";
Most of the IoT devices are running a Linux distribution, but without a clear updates and/or security strategy.
In this talk we will go through some of the current problems the IoT devices are facing and tools and strategies we can use today to make the situation a bit better for new devices, while keeping our time to market optimized.
We will show some features in Linux and systemd that can help improving the security of these devices. We will also introduce snaps, a packaging format that helps distribute your application and install it isolated from the underlying system and from other applications; and Ubuntu Core, a small, transactional version of Ubuntu for IoT devices, based on snaps.
This talk will cover the problems currently with why applications are not being sandboxed to lessen the attack surface. Mostly this is based upon the existing tools being not user friendly and requiring a low level knowledge of syscalls that is hard to find in application developers.
Seccomp is one of these tools. It defines syscall filters that allow an application to define what syscalls it allows or denies. It is commonly used in the highly-regarded Chrome sandbox.
Integrating things like seccomp filters into programming languages at build time could allow for creating a perfect set of filters based off the application code. In practice, some try to mock this behavior at runtime but it often fails due to certain functions not being called during testing and missing specific syscalls. Therefore causing the user to turn it off completely. By integrating it into the code at build time we can ensure that all the syscalls are accounted for.
This talk will also show a proof of concept with this in Golang.
Caitie McCaffrey is a Backend Brat and Distributed Systems Diva at Twitter. Prior to that she built large scale services and systems that power the entertainment industry at 343 Industries, Microsoft Game Studios, and HBO. While at 343 Industries she partnered with the eXtreme Computing Group in Microsoft Research to productionize Orleans as part of her work rewriting the Halo Services.
Microservices have become the defacto architecture pattern for building services. However separating business logic into small services that operate with a single logical data set has introduced consistency challenges. Previous attempts to solve this problem like two phase commit have not been widely adopted due to availability and liveness issues.
Instead developers implement feral concurrency control mechanism. This technique can be error prone, and often results in “Death Star” architectures which rely on chained calls to enforce application invariants. These architectures become more complicated over time, and are difficult to modify and extend, and often don't correctly handle all failure scenarios.
In this talk I propose a new solution for this problem, Distributed Sagas, a protocol for coordinating requests among multiple micro services, while ensuring application invariants.
The feature we always hear about whenever Java 9 is in the news is Jigsaw, modularity. But this doesn't scratch the same developer itch that Java 8's lambdas and streams did, and we're left with a vague sensation that the next version might not be that interesting.
Java 9 actually has a lot of great additions and changes to make development a bit nicer. These features can't be lumped under an umbrella term like Java 8's lambdas and streams, the changes are scattered throughout the APIs and language features that we regularly use.
In this presentation Trisha will show, via live coding:
- How we can use the new Flow API to utilise Reactive Programming
- How the improvements to the Streams API make it easier to control real-time streaming data
- How to the Collections convenience methods simplify code
Along the way we'll bump into other Java 9 features, including some of the additions to interfaces and changes to deprecation. We’ll see that once you start using Java 9, you can't go back to Before.
Inés Sombra is a Distributed Systems Engineer at Fastly, where she spends her time helping the Web go faster. Ines holds an M.S. in Computology with an emphasis on Cheesy 80’s Rock Ballads. She has a fondness for steak, fernet, and a pug named Gordo. In a previous life she was a Data Engineer.
Centralized applications are easy. Your entire system lives in one physical location and you can reason about, vertically scale, and manage your system without a lot of friction. Unfortunately none of us build applications this way anymore. Our systems are distributed, have external dependencies, and may even have to be geographically redundant.
Dealing with distribution is a must at Fastly where our applications are deployed all over the world and must be highly performant and resilient. But there are some inherent challenges related to designing and building systems that scale. In this talk we’ll go over the key lessons we learned while building our Image Optimization service. What worked, what didn’t, the tradeoffs we made, and what can you do as a systems engineer to learn from our experiences while building your own applications.
Even the best, biggest, beachiest data out there is useless if users can't easily search and analyze it. Under the right circumstances, a custom query language can be a powerful interface to that data, but only if that interface is chosen and developed consciously, with top priority given to creating a fitting domain abstraction, a first-class user experience, and a simple yet flexible implementation that doesn't reinvent the wheel.
These are takeaways from the real-world experiences of ÜberResearch and Valo: two different companies with very different needs, which nevertheless ended up taking similar approaches to the selection and creation of query languages as data interfaces. From the lessons they've learned -- some more painfully than others -- we'll construct a roadmap for choosing, designing, and implementing a custom query language that lets your users interact with your big, beautiful data in all its glory.
Every engineer finds themselves, at some point, in a system they want to rewrite. Often we need to take a large legacy monolith and move it to a distributed architecture, for purposes of scaling. This talk will discuss some of the challenges encountered when attempting rewrite a complex system, the key strategies for success, and the potential unexpected outcomes of such a project.
The aim of the Internet of Things is to provide valuable information about everything around us. Citizens demand open access to know directly what happens in their cities without any intermediary. But nowadays we are impacted by countless news our sources and is very difficult to digest it.
Over-information is the new way of hiding information. If we demand context and facts instead of dumb numbers, the biggest legacy of the internet of things will be a world that is more transparent and democratic. Smart solutions also improve citizens daily lives by controlling pollution levels, providing alerts against medical epidemics or managing cities' traffic.
Libelium technology has been applied worldwide. During Fukushima crisis after the tsunami in 2011 we developed a sensor board to measure radiation. As a result, a series of boards were shipped at no charge to the Tokyo Hackerspace and other working groups in Japan to allow citizens monitoring autonomously radiation levels. With MySignals, an eHealth development platform, we want to cover one of the main challenges of the century: enhancing the universal accessibility to a healthcare system for more than 2 billion people worldwide.