User:Smalyshev (WMF)/OSCON2018

Getting started with TensorFlow
https://conferences.oreilly.com/oscon/oscon-or/public/schedule/detail/66944

Introduces TensorFlow and its new tutorials: https://www.tensorflow.org/tutorials/keras/

Using https://colab.research.google.com/ as online workbench.

https://pair-code.github.io/facets/ - facet-based data visualization.

Linear estimators: https://colab.research.google.com/github/tensorflow/models/blob/master/samples/core/tutorials/estimators/linear.ipynb

https://magenta.tensorflow.org/demos - some demos, see SketchNN

https://twitter.com/TensorFlow has code examples

https://distill.pub/ - NN research & commentary

What’s your ML test score (article) - ML best practices

https://github.com/tensorflow/tensorflow - the source

Tensor Flow in Javascript - https://js.tensorflow.org/

Outcome: gained some basic understanding of how TensorFlow works when building simple classifiers or regressions, and where to look for additional information if necessary. Learned about Google online workbench tools which could be useful for working with such tools.

TensorFlow seems to be pretty easy to use to generate simple classifiers/regressions, with a lot of built-in algorithms. Recommended to use the defaults most of the time, how exactly to choose the number of layers and other parameter, and tune the default, requires more advanced knowledge.

Rusty Sword arena: A crash course in Rust
https://conferences.oreilly.com/oscon/oscon-or/public/schedule/detail/67116

Intro into Rust with an example of making simple game in Rust.

Source: https://github.com/CleanCut/rusty_sword_arena

Docs: https://agileperception.com/doc/rusty_sword_arena/

Outcome: learned the basics about Rust language, packaging system and basic tools. Gained some understanding into what Rust is about (e.g. meticulous tracking of object ownership) and how to build some simple tools on Rust.

Seems to be pretty interesting language but the ownership tracking makes writing some code frustrating and requires a lot of attention to who owns what where, especially given there's no refcounting. Not unlike C[++] though, but unlike C[++] the compiler won't let you shoot yourself in the foot.

You don't know bash
https://conferences.oreilly.com/oscon/oscon-or/public/schedule/detail/67166

Introduction into advanced bash capabilities.

Which turned out not to be that advanced, most things discussed were pretty basic. Also discussed some jq and other tools like awk.

Outcome: not much gain, unfortunately. Most of what has been discussed I already knew or could easily find out if needed, should pay more attention to talk descriptions next time.

Fundamentals of GraphQL
https://conferences.oreilly.com/oscon/oscon-or/public/schedule/detail/67508

Introduction into GraphQL as an API building framework.

Source: https://github.com/Danilo-Zekovic/oscon-graphql-starter (branches - intro-one, …, final)

Slides: http://slides.com/capouch/oscon18/

graphiQL tool - build queries in a UI with verification & completion

One endpoint - one schema

Types are case-sensitive

https://launchpad.graphql.com/j8kkn0wqnp

Outcome: learned about why GraphQL exists and how one can define an API with it. Gained some familiarity with Javascript/Nodejs tools used to build (very simple) GraphQL APIs and how they work.

GraphQL seems to be an attempt to unite schema building and API building and to make it easier to create a complex typed API schema without having to do a lot of manual work and synchronizing all parts of the API. It is an API framework, so implementation on the backend can be anything, just the API layer itself is prescribed.

An introduction to blockchains
https://conferences.oreilly.com/oscon/oscon-or/public/schedule/detail/67153

Slides: http://slides.lucywyman.me/introduction-to-blockchain.html

Basic introduction into blockchains

Outcome: gained some information about developments in blockchain word. Unfortunately, most of the talks was too basic for me, so no new information there. I expected some deeper dive into what is driving consensus protocols, chain transactions, mining decisions, etc. but that was not covered. There are some links in the presentation though, will have to read them.

https://medium.com/loom-network/understanding-blockchain-fundamentals-part-2-proof-of-work-proof-of-stake-b6ae907c7edb

https://en.wikipedia.org/wiki/Proof-of-stake

https://github.com/ethereum/wiki/wiki/Proof-of-Stake-FAQs

Mary had a little lambda: A live dive into the lambda calculus
https://conferences.oreilly.com/oscon/oscon-or/public/schedule/detail/67384

A live exercise in building Church Numerals and basic logic/control structures on top of them.

Outcome: though I knew about Church Numerals before, it was a fun exercise to go through the reminder of how they work and how much you can build basing on basic lambda calculus and function composition.

Heroic and inspiring tales of open source
https://conferences.oreilly.com/oscon/oscon-or/public/schedule/detail/67450

A talk about past and current open source movement challenges and personas. Very educational.

Outcome: learned some interesting historical tidbits about open source and how the concepts have been developed and proliferated.

Was very impressed with Danese Cooper who described the challenges open-source movement faced and continues to face and how to address them with wider and deeper perspective than many OS advocates approach it, and provided some excellent thoughts about hard questions like conflict between software freedom and desire for positive impact, and other issues in Open Source community. Unknown to me at the time of the talk, she also served as CTO of WMF, up until 2011.

How unreliable computers can usually agree (sort of): A tour of the Raft algorithm
https://conferences.oreilly.com/oscon/oscon-or/public/schedule/detail/67161

The explanation of Raft algorithm - algorithm for managing replication in clusters, implementing A(vailability) and P(artition tolerance) from CAP.

Slides: https://cdn.oreillystatic.com/en/assets/1/event/274/How%20unreliable%20computers%20can%20usually%20agree%20_sort%20of__%20A%20tour%20of%20the%20Raft%20algorithm%20Presentation.pdf

Outcome: learned about Raft and how it works, and how it can be used in distributed systems.

Hacking your emotional API
https://conferences.oreilly.com/oscon/oscon-or/public/schedule/detail/67172

A talk presenting a metaphor of emotions as an API and tools to deal better with emotional situations.

http://emotionalapi.com/

Slides: https://cdn.oreillystatic.com/en/assets/1/event/274/Hacking%20your%20emotional%20API%20Presentation.pdf

Outcome: learned some useful techniques and some food for thought about handling emotions and difficult situations.

Clean Code
https://conferences.oreilly.com/oscon/oscon-or/public/schedule/detail/67196

A discussion of code quality, how to make code better and what are the reasons code quality does not gain as much attention as it should be.

Outcome: interesting discussion, but not sure if there were any practical outcomes I could use to improve our code quality. Maybe that it is important and we should pay more attention to it :)

The IoT botnet wars, Linux devices, and the absence of basic security hardening
https://conferences.oreilly.com/oscon/oscon-or/public/schedule/detail/67369

Slides: https://cdn.oreillystatic.com/en/assets/1/event/274/The%20IoT%20botnet%20wars%2C%20Linux%20devices%2C%20and%20the%20absence%20of%20basic%20security%20hardening%20Presentation.pdf

A survey of recent IoT botnet infections and methods they use to infect the devices and propagate.

There are several "whitehat" and "grayhat" worms, e.g. Bricker, that either lock down or brick vulnerable devices. The strategy of just looking for default passwords is surprisingly (or unsurprisingly) successful.

Outcome: learned how the common IoT worms operate. For most cases, ingress firewall and changing default password makes the device invulnerable to the worm.

The async invasion
https://conferences.oreilly.com/oscon/oscon-or/public/schedule/detail/66941

Slides: https://cdn.oreillystatic.com/en/assets/1/event/274/The%20async%20invasion%20Presentation.pdf

A survey of async/await syntax in several popular languages, how it works, why it is popular and how it is improving things.

Language adoption - C#, Python, JS, C++, Rust

https://blog.stephencleary.com/2013/11/there-is-no-thread.html

Outcome: learned about several approaches to cooperative asynchronicity, their advantages and disadvanates and how async/await works in languages like Python/Javascript.

NGINX Unit - how to use the fully dynamic new server
https://conferences.oreilly.com/oscon/oscon-or/public/schedule/detail/67753

Intro for new server offering from nginx - nginx Unit.

The server can run multiple runtimes (no need for php-fpm, etc.), dynamically configured via JSON, no config files, efficient communication between processes using shared memory. Looks like it's mostly designed for environments that run mix of different language runtimes and need to manage them efficiently and have them talk to each other a lot, and maybe for those with frequent config changes (virtual hosting?)

Outcome: learned about nginx Unit system and what are its advantages.