Using traditional monitor methods of static thresholds are not practical when you have a millions of metrics and each metric has a behaviour of its own. The only practical solution is using anomaly detection methods that can really monitor all of your data and create a baseline for each one of your metrics.

The story of Re:dash, that in the past 3 years grew from a hackathon project, to a side project to a business.

I will share the story, what is Re:dash, how to transform and open source project into a business and lessons learned from this experience.

We have a great market gap in Israel when it comes to product management. The demand for world class product management is strong as our ecosystem creates companies at a greater global scale, however the supply of great product management talent is weak. In this talk I will try to convert engineers to product managers as I believe it is one of the best levers to pull in order to solve the gap. I will explain how product managers make engineers' life miserable, how to excel at product management as an engineer and hopefully inspire engineers to solve one of the biggest gaps our ecosystem currently struggles with.

Running a full stack autonomous team is not a simple task. It puts a significant responsibility on each team member's shoulders and requires a great sense of accountability. Though we try to create a culture of equality in the full stack team, the role of the leader is crucial to make it tick. I will talk about the role of the formal leader of the team - the engineering team lead, the informal leader's role - the product manager and how effective leadership looks like. So by the end of the session, I hope leaders in the audience will have more tools to lead their teams and engineers will be inspired to lead.

During the talk I will share my experience in building a remote-first team. The story began, when our team decided to join the " Hasadna " and donate our time. It was an amazing experience, We were able to merge 3 pull-requests in our first night, and The most amazing part was, We didn't physically interact with anyone. All communications and interactions were in Github / Slack.

I thought to myself, Why on-boarding on my team can't be that easy?

So, We started a journey, building a remote-first team inspired by opensource project/culture.

pol·y·glot - knowing or using several languages

There are roughly 6,500 spoken languages in the world today, and Only ~ 72 different languages made a "project" fail in the story "tower of babel". Does it sound familiar?

Arranging software development around a wide mix of programming languages and technologies offers both challenges and rewards. In this talk we will explore the pros and cons working with over 8 different programming languages in a single product.

Many teams today choose the "best tool for the job" or just creating a project in a new language or stack "just to learn", without taking into account the consequences. This talk will also discuss tips and rules of thumb to actually making polyglot teams work.

In this talk we will understand what are Genetic and Evolutionary Algorithms (GA and EA), and go over some of their applications.

At emedgene we are dealing with billions of possible and unknown genetic variants in order help geneticists understand the clinical meaning, so that they may provide their patients with the personalized care they deserve.

I will share our experience in training a neural network using genetic algorithms to solve the human genome problem.

The full story behind a highly successful immune system we implemented for the "New Google Sites". We will discuss key decisions and present the design of the system that we built, touching a wide range of devops topics:

• Production tests
• Webdriver vs. RPC probers
• What environments we have and how are they pushed (CI/CD, etc.)
• Capacity testing, load testing, Canarying
• What worked, what went wrong, and what were the surprising wins
• Blackbox vs. whitebox alerting
• Capacity planning and request costs
• What the oncaller dashboard looks like
• Postmortem culture

This is an inspiring presentation, full of interesting professional and cultural stories from our development site in Autodesk-TLV about how we grew 10x and fight for:

1. Passion & Innovation - finding a way to feed our professional fire.
2. Collaborating - breaking down silos.
3. Keeping the Seventh Commandment - You shall love your neighbors as yourself.

Agenda:

• Site Story
• Communication Channels
• Autodesk TLV Bubbles (Lightning talks)
• Internal Dogfooding
• Blog Contest
• Pets and Productivity
• Professional Guilds & the Sharks Program
• My.path - Empower Learning & Professional Development Designed for
  Today’s Workforce
• Extracurricular Activities
• Meetups
• Jedi Day & Bazinga (Hackathons)
• Artisan - An Innovative Way to Attract Talents

A CDN is part of the toolkit any successful web site or web application should be using. However, different CDN solutions vary significantly in their global and local performance, have different features, and are fit for different use cases.

At Globaldots we work with 15 different CDN vendors.

This talk will show the key things to look for in a CDN, and suggest some measuring methodologies we adopted when selecting a CDN for a project.

she codes;הוא ארגון שמטרתו להגדיל את מספר הנשים שבוחרות בהייטק כמקצוע. כיום יש כעשרת אלפים נשים שמשתתפות בפעילויות הארגון על פני 24 סניפים. בהרצאה נדבר על האתגרים שעומדים בפני נשים שכבר בהייטק וכאלו שרוצות להיכנס ואיך she codes; נותנת מענה לאתגרים האלה

This is not yet another technology list, buzzword packed, look-how-good-we-are show off. Actually it is technology/language agnostic and I promise not to say Docker even once ;)

The newcomer into this world is overwhelmed with information, patterns, tools and practices. Having delivered numerous such projects, I'll try to separate the wheat from the chaff.

This is a clear recipe for the key practices you should keep when building continuously delivered microservice.

On Autodesk Tel-Aviv office you can find many employees working on different products of different teams and groups, which encounter the same challenges every day. We decided that we must find a way to brake the boundary of our office walls and share the knowledge with all employees from all over our site. For that purpose, we started the TLV-Guilds: A guild is basically a group of people that work on the same technical domain and will love to spread the knowledge internally and externally. We currently run 7 different Guilds : Graphics, iOS, Quality, Server, Web, UX/UI, Product.

Agenda:

• A short description of our Guilds:

(a) Graphics (b) iOS (c) Quality (d) Server (e) Web (f) UX/UI (g) Product

• Roles inside a Guild:

(a) Master – The leader of the guild. (b) Sponsor – The sponsor supports the master with any needed help or consultation. (c) Member – An active professional who contributes to the guild.

• Vision and Goals:

(a) Professional development for the employee (b) Personal & Autodesk TLV reputation (c) Development and/or sharing of frameworks/tools/disciplines for the site & company (d) Tech innovation and progress e) A sense of belonging (f) Being an individual influencer and getting promoted, not only on a management basis

• Activities:

(a) Organize internal/public meetups & attend other meetups (b) Blogging, Open Sourcing (c) Knowledge sharing (d) Initiate and work on shared projects (e) Problem brainstorming, Code reviews

• Personal stories of the benefits of being a part of a guild & Autodesk TLV site.

The demand for managing a large amount of data in a scalable yet reliable and cost-effective way has became more and more relevant in this day and age.

Ceph, a software-defined storage, provides an original solution for this problem and guarantees a resilient and self-healing way for managing large amount of data up to the exabyte level.

In this session I will talk about a new feature introduced in oVirt 3.6, which provides the ability to integrate with Red Hat Ceph storage using Cinder, a storage service used mainly for OpenStack.

This integration reveals new opportunities and tools for storage management in a scalable and virtualized way and also opens the door for interesting future integrations with other storage providers.

Big Data is all about generating some extra value out of existing data.

In this session we will go over a business and technical process where a SaaS CRM provider utilized a graph engine (Neo4j) to explore its customers data, to find synergies between existing customers and generate new value tp the customers and enable network effect for the provider itself.

At Ravello Systems we were relying heavily on CI/CD since the very early days. During the first 4 years of the company, our CI/CD framework changed and evolved to the point it went out of control and we decided to take all the experience from these years into a new and improved CI/CD. This session will share the lessons that we learned when we used multiple different tools as part of our DevOps work and why we choose to move to Ansible for provision environment on demand, setup vm, deploy code and orchestration of our tests flows.

We would discuss the process of re-doing the CI/CD from the beginning in small steps over more than a year while a large always developing group continue to push changes to production on daily basis.

To support the move we added new Ansible provisioning module that create environments in Ravello and new inventory for those environments. Since our backend is deployed in AWS directly and our tests runs on top of Ravello we added abstraction layer that allow us to write roles and playbooks that works on both environments without change. We will describe the technical aspects of this move including Jenkins integration, deployment module we developed and how we build and install client product we develop on multiple OSs.

We tend to think that strong developers that are also "good" people always make a successful dev team. However those of you who have been around long enough know this is simply not true.

Having talented people on board is crucial. And yes, making sure they are team players is important as well. But indeed, there is another more elusive ingredient which makes or breaks a dev team.

In this short talk I’d like to tell you what the secret ingredient of the successful team is, how it relates to being or not being agile, and how you can use this insight to your own benefit starting now.

Back to the Future, Star Trek, Terminator - Almost every sci-fi movie we grew up on presented some slick futuristic technology. But while some of these films turned out to be successful predictors of the future, others missed miserably.

From hoverboards and tablets to telleporters and time travel - Which technologies were successfully predicted? Which movies shamefully failed? And what can we learn from it all?

In the talk we'll describe the security architecture we use to provide SaaS for advanced code analysis and indexing, while protecting customer code. Together with Wix, we came up with a solution that keeps the customer code safe even if Codota's database, application servers or employee laptops are compromised. We'll go over the alternatives we considered, the tradeoffs, the solution of choice, benefits, challenges and how it works in practice. We believe that the solution is applicable in other settings and welcome others to build their own variation of the same concept. The talk will be given together with Nadav Wexler from Wix backend infrastructure team.

במשך עשרות שנים, כמעט לא חלו שינויים בהגדרות של בסיסי הנתונים הרילציונייים. לאחרונה, הם מאותגרים ע״י בסיסי נתונים NoSQL שפותרים מספר בעיות מסוימות מאוד. אך מסתבר שהוספת שכבה זעירה מעל גבי בסיסי נתונים רילציוניים, בלי לשבור דבר בתאימות שלהם לאחור, משלשת את יכולותיהם ומאפשרת דור חדש של ישומים ופריימוורקים. שכבה זו מפותחת בארץ בקוד פתוח, בשלב ראשון מעל גבי פוסטגרס.

בין היכולות שנוספות בזכות שכבה זו:

א. טמפורליות שהופכת את בסיסי הנתונים הטבלאיים ל״קוביייתיים״, תלת מימדיים, כשמימד הזמן מאפשר תכונות מדליקות שעד כה ניתן היה רק לחלום עליהן, שתודגמנה במהלך ההרצאה.

ב. תמיכה טבעית בסוגי נתונים מודרניים, כמו למשל תיוגים

ג. הכללתן של ה״סכימות״ בטבלאות, כך שכל משתמש מתחיל יוכל לבצע משימות שבעבר רק DBA היה יכול לבצע.

ד. הכללת הקוד שמיישם את התוכנה, בטבלאות, כשהטמפורליות מייתרת מערכות ורז׳נינג כמו גיט, ובתקווה שלא יזרקו אותנו בגלל זה מגיטהאב... ;-)

ההרצאה מתוכננת לכלול בעיקר הדגמה חיה (זה מה שכולנו אוהבים, לא?). דרישות מוקדמות: רצויה הכרות בסיסית עם SQL, להבנת ה- live-coding.

What do you do when your project is over 20 years old, with tons of legacy code, and tight coupling with OS configuration? Do you let it slowly stop you from developing it further and start from scratch, or do you take the task head-on and start working on the problem(s)? During this talk I will try and showcase the moves the IDF Navy C4I Dev. Group took in order to become more agile than ever - moving from a manual and slow release process (months), to being able to ship (literally) a version every few days. We'll try and cover the Open Source tools we put in place in our CI, and also some of our own creations - such as the Dojo build system and our automated testing infrastructure MBR. These projects are the ones we are thinking about making Open Source, and would love to know if they interest the community.

Note to organizers - if accepted, our proposal will need approval from IDF Censorship and Cyber authorities.

One of the main premises of React Native is delivering apps with the same feel of an app that was implemented 100% natively. RN achieves this by rendering your entire UI natively. JS is only the driver behind the scenes, the actual components on screen are the same native components every traditional native app uses.

While this is true for the most case, we've discovered that it isn't true for your app skeleton. Components like the navigation bar, tab bar and side menu are encouraged by RN to be implemented in JS. This is strange since these are important components for attaining the seamless native feel of the OS.

The reason behind this is partly technical. The architecture of RN equates native views with React components . The problem with skeleton components like the tab bar is that they aren't simple views - they're something above - ViewControllers in iOS, Activities/Fragments in Android. Therefore, they're out of place in the React architecture.

At Wix.com, we've started an open source project that aims to bring these types of components back into the RN ecosystem. We use this project in our production apps.

The project is called react-native-controllers and available on github here: https://github.com/wix/react-native-controllers

The technical aspects behind wrapping controllers are very interesting, we'll go over them in general in this talk. For a fuller discussion, you're welcome to read the project's README on github, it's very detailed.

Abstract

At Wix.com, we’ve been betting big on React Native. The official Wix app is developed completely in React Native and designed to cater to Wix’s growing userbase of over 80 million users. Production of this scale comes with its set of challenges, especially when using a framework this young.

Background

There’s a difference between fooling around with React Native and making a hardcore app where dozens of developers work together on a single codebase with the purpose of catering to millions of users. Mobile Engineering at Wix.com was willing to make a bet on React Native, and we want to share our experiences and talk about our journey.

Developing quality native apps is challenging in a company like Wix. We have about 200 Javascript front-end developers and only 10-20 native developers (both iOS and Android). The core of the the Wix product is web-based. It’s obvious that in order to bring the product into native mobile form, we have to rely on the existing workforce and leverage the existing skillset. React Native makes this work, as 70% of our code can be in Javascript.

We’ll touch upon different aspects of our dev flow, like: how we break the app into modules which have their own lifecycle (snapshot/RC/GA); manage dependencies for multiple teams in one bundle; use redux in our architecture for maintainability and testability; separate concerns between different dev teams using IPC; perform testing - both unit tests, component testing, e2e automation and QA; move towards continuous integration and delivery; perform deployments and over-the-air updates; do crash/exception monitoring with tools like NewRelic; report to multiple analytics providers events with custom middleware; separate development between native and JS.

Another interesting aspect is how we divide our engineering teams between native developers and JS developers. What does each group do and when do we move tasks from one type of developer to another.

The Red Hat Mobile Application Platform (aka FeedHenry) is one of Red Hat's recent acquisitions, as part of their open hybrid cloud strategy, offering developers the flexibility to create web apps and supports a wide variety of popular developer toolkits and frameworks.

The presentation will be focusing on some of the tools the mobile application platform provides and how I used them to develop a small application called gerrit-notif, an open source project which creates notifications on a mobile device for any gerrit events, such as changed score, status and other patch update.

Abstract

React Native holds great promise in terms of excellent developer experience with Javascript and code reuse between platforms. The big question is  —  do these benefits come at the price of performance? How well can React Native hold its own against purely native implementations?

Background

I’ve been developing native mobile apps professionally for the past 7 years. I’ve seen many magical “cross-platform” solutions but eventually nothing beats pure-native in terms of app quality. The main thing developers are skeptical of is performance. React Native is unique in its ability to achieve amazing performance, but it requires developers to understand what goes on under the hood. The aim of this talk is to ease concerns for new-comers and teach existing developers a few important guidelines.

Audience

I can give this talk in a very abstract and introductory level, without showing much code. This would accommodate a mixed audience where many have never written actual React Native code. The focus would be the general architecture of React Native, how the bridge works, how native plays with Javascript and how conceptually modern RN libraries tackle performance issues. I can also give this talk to a more advanced audience, where people work with React Native professionally. The talk in this case will dive into actual implementation techniques, show code snippets, compare them performance-wise and provide actionable guidelines to know where to expect their app to falter and what to do about it.

Materials

While I was working on this talk, I’ve organized all the materials for the advanced format (including code snippets and an actual example app) in a blog post on medium , which was well-received in the community.

Jenkins is the most popular DevOp tool nowadays for continuous integration.

During this short session I'll cover the following: -- Which components you should monitor on Jenkins masters and slaves -- What metrics you should be tracking -- How to deliver faster!

A lot have been said and written about Organizational Culture. Any recruiting company takes pride at 'dynamic/open/achievement-driven/whatever DNA.

• What is this 'culture' thing?
• Is it just derived out of the people you are? Those you hire?
• Can you control it?

Using practices and tools of the open-source community is a great way to guide, cultivate and nourish your organization's culture. In this talk I will share what's been working for us at Kenshoo, and give effective points on how you can start leading your own cultural change.

No doubt that software architecture have seen a lot of changes over the last years. But what about the role of the architect? Actually, what exactly is the role of the architect?

Over the last year I have made the shift from managing and leading teams into the position of Chief Architect @Kenshoo. This turned to be much more challenging than I thought it would be. I found myself spending many hours at figuring out what should I be doing.

In this talk I will share this journey and insights , on the what and how of being a modern Software Architect .

Coderetreat is a day-long, intensive practice event, focusing on the fundamentals of software development and design. It is also a lot of fun .

We at Kenshoo are doing those periodically - hear why, and learn how you can start as well.

• Move fast, always trying to be faster.
• Being in full control is a dangerous illusion, the cost of mistake can be high.
• Focus on navigating through the constant stream of unexpected events.

The above describes both riding a motorcycle and leading an agile team.

A motorcycles is the essence of agility, it is designed to carry a (very) small batch of people from A to B as fast as possible. For that, sport bikes need to give up any fluff, cut out all that is not essential. This is pretty much similar to what agile delivery teams are all about.

Let's demonstrate with another simple example. overtaking a line of cars is a calculated risk bikers take. You don't have to do it, but it can gain you great progress. A good rider would have planned an escape route in case he gets surprised. (A plan which has more than just dropping all that you have on the breaks).

Overtaking is kind of like committing to a delivery with a large unknown chunk in it. You don't have to do it, you can play it safe. But, if you do go for it, the potential for success is great. A successful team would have planned their execution with "escape routes". For example by delivering core first, and then wrap it with additional layers. Having a plan on how to deliver partial content if things go bad is a great technique. Follow it to allow your team to push stronger while reducing the risk.

In this talk, you'll learn a bit about riding motorcycles, and what techniques can be applied to do it well. More importantly you'll see how those principles are also a great advice for the agile team lead.

Apache Beam provides a unified model and a set of SDKs to build data processing pipelines, in a way that transforms how you write a data processing job. A Beam pipeline can be executed on different processing engines - Spark being the most popular and the one I'm leading the development for. In this lecture I will share both the experience of developing Beam and how it transforms the day-to-day job of Big Data engineers.

The Beam SDK let's you write your pipeline programmatically, and once you've created your data processing pipeline, you can execute it on your favourite Big Data processing engine; wether it's an open-source engine such as Apache Flink and Spark, or a service such as Google Cloud Platform. You can also just get started with the in-memory runner that is included with Beam.
In addition, Beam let's you execute the same pipeline for either batch or streaming, so no more duplicating your code just because your data source changed.

The Beam model tries to solve the problem of stream processing by taking into account out-of-order processing and event-time processing, and by asking the right questions regarding the "unbounded" data processing (streaming) problem, and modeling "bounded" data processing (batch) accordingly.

Finally, your pipeline is "future-proof" by being portable to use on any future distributed-processing back-end that supports Beam.

Apache Beam (incubating) website
Apache Beam source code

Note: I have no problem presenting in English as well.

If you don’t use @flow This 5min talk will save you hours!

In this session I will cover why you should use @flow, how you can start using it in 30sec and why it will change your life!

So just give me 5min to rock your world :)

Avoid the pitfalls, don't make the same mistakes I did!

Everyone heard about React Native, but how many people do you know that made a production app with it?

In this talk I will share my experience with React Native the good & the bad parts (that no one talks about). What you shouldn’t do and what you should do!

If you are using React Native or thinking about using React Native this talk is for you!

Outbrain is recently POCing ScyllaDB as alternative to Cassandra. In the talk we will describe the need to find alternative to Cassandra.

We will describe the solution Scylla is offering. The talk will concentrate on how to manage such POC, how to run it safely on your production environment to get the best results. We will talk about the faults in the process and how we solved them. Finally we will present conclusions and lesson learned.

At Outbrain we are working on a complex UI development and with LeonardoJS, a recent open source development, we hardly need a server when we develop, in this talk I will show you how working with Leonardo speeded up our development process dramatically, enabled us to build a robust end to end testing environment, which boosted our productivity and quality of product significantly, we can easily mock backend responses with real app behavior like latency, no data, a lot of data, etc…

Speaker: David Buchbut (& Sagiv Frankel).

This talk is designed for about 30 - 40 minutes with live coding but can also be a 5 minutes talk

In recent years, deep learning as leading the forefront of machine learning and artificial intelligence. I will give a short introduction to deep learning with historical perspective. Most of the talk will be dedicated to reviewing the latest state-of-the-art examples in image processing, text understanding, and other applications.

Reactive applications are not the future, they are the present. In this talk I will explain what exactly reactive applications are. I will also introduce the “actor model” which lets us build such scalable applications easily.

In the session I’ll focus on the Akka toolkit which is a state of the art tool for building actor-based reactive services. I’ll discuss Akka’s core architecture and design and demonstrate the advantages of this development approach.

Everyone agrees that in today’s Software Development landscape, the rate in which new frameworks and paradigms change is ever-increasing.
There’s no shortage of talks in conferences about the fundamentals of microservices, Node.js v6.0, and React\Angular 2.0, but very few about how to adopt these into your existing application.
And on top of that, the “Getting Started” sections of new tools cheerfully assume that you’re starting out with the Tabula Rasa of “Hello World” and don’t provide any migration techniques.
Unless you maintain a tiny codebase, then you instinctively feel that it’s challenging and very time-consuming to migrate, but no one is talking about how to handle and manage this type of process.

In the face of the widespread case of “Legacy Code Denial” in our industry, this talk will focus on how to accept, manage, and transform a large existing codebase.
We’ll cover:

• Evaluating new technologies and forcing yourself to filter out the fads with “innovation tokens”.
• Learning and teaching new tools, overcoming a steep learning curve, creating workshops and “brown-bag sessions”.
• Different approaches to transforming your codebase including using “codemods” (code-modifications tools) to automatically transform your code with confidence.
• Reducing risk and bugs when refactoring with tools like Gradual Rollout and Github’s “Scientist” library.

A few years ago if you could crash our site by refreshing it too many times. In a matter of a year we built tools, measurements and the most important secret sauce – CULTURE that eventually enable us to provide one of the fastest experiences out there. In this talk I will provide a glimpse to steps you too can take in order to make your organization performance savvy and your website super-fast.

• Performance – say what? Why is that important? Why should you bother?
• End to end performance – how fast are your users “feeling” your website is? How to measure an “experience” performance? How to make it “feel faster?
• Load endurance, stability and resiliency – How to make your site not only fast but also endurable to massive load during pick times and how to endure and sustain failures
• Culture Hacks – probably the most important factor – providing the best tools and progress won’t get you anywhere without the right culture – how can you make your entire organization become performance savvy?

You’re the world’s best and most hard-working developer! But not everyone at your team find it as easy as you do to always write tests, close bugs, review their code, etc.
Turns out there’s a way to keep everyone motivated enough to do these things, while even enjoying it.
This short talk is about using “gamification” as part of your internal process and spicing up tedious tasks with a bit of fun and rivalry.
It’s safe to assume most of your fellow developers identify as geeks and are into pop-culture\gaming\memes, so we’ll also show some specific examples that involve these themes.
We’ll also share some DOs and DON’Ts when using this approach (like don’t use “Game of Thrones” Spoilers- we’re not monsters here).

We all know the feeling – “What I am looking is not out there ,All the good ones are taken and everyone I meet doesn’t fit”. This is not a story about a bad streak of blind dates, it’s the title of several conversations I had during my pursuit of finding a team leader to join our R&D team. Recruiting a team leader took us over a year and after having successfully accomplishing it I can share that it has taught us a few lessons about:

• DNA (?!?!)
• Leadership –when you expect every member in your R&D to be a leader, what can you expect from your leadership
• How to grow the people you already have to leadership positions)
• Understanding yet again that titles don’t mean a thing
• Interviewing is a personal growth process
• Importance of keeping the bar high while keep searching for that unicorn, even when you lose hope of finding it

If you take delivering a fast web experience seriously, then you have to make sure you’re utilizing HTTP’s ability to serve the response in chunks.
Using “Chunked Encoding” improves performance by letting your server flush critical parts of the document (like the <head> tag) early, which means the browser can start downloading other resources sooner.
And even though this has been part of the HTTP protocol since 1997(!) there hasn’t been a tool that lets you see when a flush takes place.. up until now.
“Chunk Scatter” is a tool dedicated to solve this by visualizing the point in time each flush occurred. It also shows what part of the document the client gets in each chunk, and lets you compare one endpoint to another (e.g. staging vs. production).
“Chunk Scatter” is used by engineers at Yahoo, Adobe, Atlassian, Radware, Kayak, and others to test how different configurations and environments handle flushing.

Think about the new tools that are taking over the Javascript ecosystem: Babel, Typescript, Rollup, ESLint, and smarter IDEs.
What do they all have in common: they all take Javascript source code as input, and some emit Javascript code as output.
This talk will be a deep dive into the basic building block all these tools share: Transforming your code into a JS Abstract Syntax Tree (AST).
You'll learn to read, traverse, and manipulate the AST so you can extend Babel by writing your own plugins, or by writing a custom ESLint rules to enforce your team's code conventions.
You'll also learn how to create super powerful "code-mods" to automatically convert thousands of legacy ES5 scripts to ES6 in seconds.

Okay, confession time. We’re running on bare-metal. Yeah, we know, “cloudify all the th1ngs” and all that, but that’s a different topic. And just so you know, there’s a dirty little secret concerning bare-metal. The network, right? It’s on you. All of it. Now that might not sound like much with a couple of half-filled racks, but how about a few thousand nodes? How do you scale that thing? Or automate it? Test it? ... Wait, can you even do that?

Outbrain has recently launched its next-generation LAN topology. And the switches? They’re running Linux. And Chef. And there’s not a single VLAN in sight. It's all treated as code - installation, config, even wiring.

In this talk, aimed at folks who don’t know what an SFP+ connector is, we’ll tell you about our journey into a brave new world of network automation, scale and my-god-will-this-even-work type of solutions.

Have you ever been so afraid of failing at something that you decided not to try it at all? Do you invest most of your efforts trying to avoid failure? Everyone I know is afraid of failure. It’s human nature. When we go outside of our comfort zone, we feel scared. As professionals, our identity becomes so wrapped up in what we do, that when things do not go as we expect, we are absolutely devastated. How can (and must) we learn to use failure to our advantage, rather than fearing it? Let's talk about a few strategies to get through our fear of failure and carry on, regardless of the outcome. Because if you have never failed, it only means you're not trying hard enough.

Have you presented anything lately? Maybe you are an architect trying to sell your technology vision to your company? Or are you a developer showing your design to your team?

How many times have you presented in front of an audience and it was hard to capture people's attention? Hint - the visual design of your slides has a lot to do with it.

This presentation is a cheat-sheet on how to hack your slide design. You don’t need to be a designer (I’m not) but rather to understand some basic concept in slide design. If I can do it, everyone can. Checkout some of my tips at LookAtMySlides

The session will be packed with practical tips anyone can implement from day one.

TDD isn't news, and most everyone agrees that writing tests (before, during or after implementation) is valuable. Hardly anyone agrees on what good, clean tests look like, though; if your tests are a live specification of your codebase, don't they deserve the same care and attention as your production code?

This talk focuses on how to keep your tests readable, simple and maintainable. Specifically we'll discuss how the "given-when-then" pattern affects the way you factor your code, and showcase the remarkable differences between a sloppy specification and a well-factored one.

Moderate experience with testing is expected; knowledge Scala might be helpful but is not required.

I started work at Klarna four years ago, and for the first time in my life I was surrounded by developers all day long. I found myself feeling like Captain Kirk when he first met Spock.

I'll tell you a bit about working with developers from my personal perspective.

I'll share the things I've learned about you, the differences between people in HR and developers, and talk about what we can do to make our work together better.

AngularJS is one of the most powerful Javascript frameworks for modern web these days - and it's here to stay. However, maintaining your application performance while scaling is extremely challenging.

Have you ever had data component which takes several seconds to load? Drop down opening after 1500ms? A trigger which blocks the entire page? This talk is for you!

In my talk I will share with you our experience in measuring and detecting performance issues, comparing multiple solutions, and applying them safely to a large code base.

What can you do with dozens giga of new data every day? Well, we think that absolutely everything. All our business, product and development decisions are based on the data predictions. We believe that data is power and everyone should learn to use it in the right way.

The web makes it possible for anyone, anywhere in the world, at any time, to access your site or app. But if users in Australia aren't able to access it on Friday night, when will you know about it? And if 5% of American users get a blank page instead of your site, how soon will you find out? In this session I'll cover the tools and techniques we use to monitor access to over 80 million sites hosted on the Wix platform. I'll explain how we are able to identify problems and address them quickly, minimizing the impact on our users. And I'll show how you can apply this to your own sites and apps.

Every company, once starting to grow, getting to deal with the question of how can we manage our data in an efficient way. The challenge is even greater in an agile pacing company like Fiverr. Understanding and managing data is a vital part of a successful product. In this talk we will explain the organisational structure, the data architecture and the new methodologies we apply to be a data driven company.

A lot has been said about how TDD (Test-Driven Development) is great for building up a developer’s confidence when changing code. However, TDD has its blind spots. By definition, you can't test what you didn’t develop, i.e. other systems you integrate with. In this talk, I'll demonstrate how despite of using TDD, a simple code change was the cause of failure in other systems. I'll explain why this happens and what you can do to minimize intersystem communication failure.

As a company grows, scaling its code base is inevitable and comes at a cost: lack of structure can hinder code reuse and new code is written while legacy parts are left behind, causing code refactoring to become a frightening or even dangerous task.

When dealing with Angular applications, this is where reusable UI Components can help. The ability to develop a set of extendable Components, each with its encapsulated behavior and well-defined interface becomes a crucial factor in scaling the development of large UI applications.

In this talk we will discuss the following topics:

• What defines a reusable UI component
• Why and when we should encapsulate a Component from its surroundings
• How to create Components with a “well defined interface”
• Design patterns: Composition vs. Configuration
• Choosing the “right” amount of abstraction

The flood of tools and frameworks in the front-end development world caused both the developers and their employers to lose sight of the things that really matter - software craftsmanship. It’s demand for Angular over TDD, SASS over SOLID. This loss of focus from the essentials is in the long run damaging and sadly - it is all self-inflicted. In this talk we will go over the long-term effects and explore solutions.

Meritocracy: a political philosophy which holds that power should be vested in individuals almost exclusively according to merit.

If you're reading the above, nodding your head, wishing it was the case in your situation maybe I can help. I'd like to offer some ideas and tips for the struggles Technical Leads or Senior Engineers are facing:

• How can you leverage your skills to move the organization when you don't have the authority?
• What should you pay attention to when giving an advice?
• What can you do to get your concrete suggestions deployed to production instead of perishing in the source control?
• How should you work with your manager to plan and execute an agenda you actually believe in?

“The Dunning-Kruger effect is a cognitive bias in which relatively unskilled persons suffer illusory superiority, mistakenly assessing their ability to be much higher than it really is”

It is known that developers don't necessarily make good managers, yet most companies (us included!) make the mistake of "promoting" successful developers into managerial positions. That is flat out wrong.

A developer transitioning to a managerial position might find herself in one of the most difficult positions for a manager: a new team, managing people who until recently were her co-workers. Most tech companies offer very little, if any, training for first-time managers; without the tools, training, or even having a clue as to what their job is, it's no wonder that many first-time managers fail. Yet we as an industry keep putting ourselves in this dangerous position, where failure can have catastrophic effects on the organization as well as the people involved.

In this talk I will discuss some of the mistakes we’ve made at Wix and the system we’re working on to support managers making their first steps including coaching, training and teaching.

About a year ago, I set out to build an open-source command line debugger for .NET applications. Why would I do such a thing? Well, first it turns out that in some scenarios, you really can't use Visual Studio -- when you're on a production box, for example. What about WinDbg, then? Even if you're OK with WinDbg, which few people are, it has a fairly arcane syntax even for simple things, and it can't be easily extended with .NET code. And finally, there are some really cool things that a debugger can do with the Microsoft CLRMD library, which provides a .NET API to the internals of the CLR heap, execution engine, threads, and call stacks. Thus, msos was born -- a purely managed, command-line debugger that has a bunch of innovative commands. Innovative commands? Yes, like heap queries that filter and print heap objects based on their contents; like automatic deadlock analysis (with support for unmanaged synchronization mechanisms coming soon); like a simple to use system for analyzing a bunch of dump files and getting a quick triage result. In this talk, I will share how I built msos, and show how some of its cool features can be used to solve complex bugs easier than ever before.

Imagine you're tackling one of these evasive performance issues in the field, and your go-to monitoring checklist doesn't seem to cut it. There are plenty of suspects, but they are moving around rapidly and you need more logs, more data, more in-depth information to make a diagnosis. Maybe you've heard about DTrace, or even used it, and are yearning for a similar toolkit, which can plug dynamic tracing into a system that wasn't prepared or instrumented in any way.

Hopefully, you won't have to yearn for a lot longer. eBPF (extended Berkeley Packet Filters) is a kernel technology that enables a plethora of diagnostic scenarios by introducing dynamic, safe, low-overhead, efficient programs that run in the context of your live kernel. Sure, BPF programs can attach to sockets; but more interestingly, they can attach to kprobes and uprobes, static kernel tracepoints, and even user-mode static probes. And modern BPF programs have access to a wide set of instructions and data structures, which means you can collect valuable information and analyze it on-the-fly, without spilling it to huge files and reading them from user space.

In this talk, we will introduce BCC, the BPF Compiler Collection, which is an open set of tools and libraries for dynamic tracing on Linux. Some tools are easy and ready to use, such as execsnoop, fileslower, and memleak. Other tools such as trace and argdist require more sophistication and can be used as a Swiss Army knife for a variety of scenarios. We will spend most of the time demonstrating the power of modern dynamic tracing -- from memory leaks to static probes in Ruby, Node, and Java programs, from slow file I/O to monitoring network traffic. Finally, we will discuss building our own tools using the Python and Lua bindings to BCC, and its LLVM backend.

Working on a large scale JavaScript project with dozens of developers is hard. In this session we will show you why TypeScript a superset of JavaScript that compiles to plain JavaScript will help you boost your project

Obvious ways to get performance wins are obvious. By the end of 2016, every application developer should know about concurrency and parallelism, ORMs and web response caching, efficient collections and garbage collection internals. But there are so many performance wins ripe for the picking that most developers don't know about. This talk is all about squeezing the best performance out of modern hardware. And modern hardware is about vectorization in addition to parallelization; modern hardware is about optimizing your instruction flow and data layout for last-generation instruction sets and cache structures; modern hardware is understanding that using 4 cores is not the same thing as using 44 cores; modern hardware is about using tools to determine where bottlenecks lie and not about guessing. This talk dives deep under the covers of your processor and memory system to deliver top-notch performance. We will see multiple examples of optimizing CPU- and memory-bound algorithms that are used in real-world applications, such as finance, image and signal processing, and many others.

Promises provide a simpler alternative for executing, composing, and managing asynchronous operations when compared to traditional callback-based approaches. In this session we will take a look under the hood in order to understand what make promises tick

Learn how easy it is to learn and use Elixir and Cowboy (A concurrent and fault-tolerant HTTP server) in a short time - from figuring out how to build a distributed In-App messaging system, to deployment and production. You'll also hear about why Erlang/Elixir are perfect for realtime messaging.

There comes a time in every product's life when it has to get someone to do something. Sometimes, something that someone doesn't want to do. In this talk, we'll break down motivation into hardware - the brain and how it affects our behavior - and software - the principles, habits, and biases that run our behavior. We'll analyze successful products and extract the mechanics they use to influence our behavior. Finally, we'll see how to apply Playful Thinking to create a pleasure-maximizing product experience. Bonus: participants will instantly receive a "Motivation Engineer in Training" badge :-)

In a world full of noise, how will your product break through, and get you to take action?

Cloud Foundry is an open source cloud platform as a service (PaaS) on which developers can build, deploy, run and scale applications on public and private cloud models. The cloud foundry become the leading open stack for industry cloud-based application development.

Cloud Foundry is optimized for:

• Fast application development and deployment.
• Highly scalable and available architecture.
• DevOps-friendly workflows.
• Reduced chance of human error.
• Multi-tenant compute efficiencies.

DSLs are everywhere. Have you ever used SQL, Ant or maybe HTML? If so you were using a DSL, maybe without realizing it. Domain-Specific Languages, or DSLs, provide convenient syntactical means of expressing goals in a given problem domain. A well-crafted DSL communicates the essence and means of the domain it represents in a natural way, so that you don’t even think about its underlying technology. ​ Scala’s rich, flexible syntax combined with its OO and functional features makes writing DSLs a breeze. In this talk I'll introduce the concept of DSLs, where to best apply them, their pros and cons, and how to integrate DSLs into your core application. We will see a practical example of how to lever the tools Scala gives us and build our very own tax calculation DSL.

We decided to redesign - not refactor - one of our must successful products.

In this lecture I will present the reasoning behind this brave decision, while quickly presenting the previous system and its pains; such as a monolithic server, the inability to scale as the product grew, and suffering from a low dev velocity.

Then, I will share our arduous thinking and planning process, and the solutions we came up with such as the use of micro services, CQRS and event sourcing.

I will further share my challenges as the R&D Lead of this redesign and what I've learned during the process. Come and hear how it all ended.

At first glance, the coffee machine at the Google’s offices in Tel Aviv looks innocent. But in fact, someone worked very hard in designing it to be truely “inconceivable”, so that most first-time users will give up using it, frustrated, humiliated and with no coffee. Now imagine this happens during a short break of an angular-directive or big-data technical talk. Oh man, you definitely need that coffee! Desperately!

So what do you do? You start looking around. It is hard to admit it, but you need help. You need to find someone that knows what to do and that is willing to show you how. Yes, you need a friend . A smart and patient friend that will help you get the damn coffee...

Well, this phenomena is not restricted to coffee machines only. As software applications users, it is easy to imagine it happening to us when using a new photoshop feature or trying a new Amazon service. Then, again, we hope to find the right friend.

My story is about that friend.

In the UI of our SAAS application (Ravello Systems) we have introduced a “Virtual Friend”. A contextual on-request Robot Friend, that will make sure you’ll never walk alone. This friend will show you, step-by-step, the way to accomplish your job in your own environment and using your own data. It will explain, instruct, point and hold your hand until you fully complete your job (it won't make you coffee, though :).

In my talk, I will present the very first ideas that led to the development of this virtual friend, ideas that were born more than 10 years ago during an academic research. I will describe and demonstrate the way it came into live in a working and successful system, will discuss the UX considerations, the software design and other technical details. Eventually, I will share some future ideas for other usages and improvements.

Open Source content management systems like WordPress and Drupal power over 40% of the web. But developers are sick of them due to their clunky, buggy and highly hackable nature. Many devs are turning to static website generators to overcome the issues faced by these CMSs, however these solutions don't take site owners and end users into account since they won't be able to easily manage their content on their sites.

So, the talk is: making dynamic static. Yup, opposites can attract.

We are all constantly told that having a healthy work-life balance is critical, but what does it really mean? Can we really separate life and work? Forget everything you ever heard about work life balance, and find out what you can do instead.

An introduction to the architecture of a multilevel feature that lets the user upload a virtual disk file from his PC into oVirt's cloud storage. oVirt is an open source project for managing virtual machines and datacenters.

My presentation is about how features that seems like a simple idea are starting to be complicated and cumbersome as the development progresses. The presentation actually shows an example of a feature that we (storage team, oVirt) are developing, which was initially described in a very simple diagram- and went on to a bigger and bigger one, because of many considerations like security, efficiency, scalability, etc. During the presentation I will present the actual diagram taken from the feature's web documentation- and its prior versions, while explaining why did it evolved that way, explaining the technical considerations- which are relevant considerations for every development process.

It all starts with working together. The term "DevOps" holds much more than just a new job description for operation people. For us, it is a way of life. We create our own flavour of DevOps organization, including system ownership, combined teams, tools and much more. This will be our chance to share our good experience about how it can actually be done and why it might be good for you, your DevOps team and your business.

https://github.com/BorisKozo/subdivision

Subdivision is a somewhat opinionated JavaScript library that helps you structure your code in a highly decoupled way. It is conceptually based on a battle proven Addin-Tree concept used in projects such as SharpDevelop (C#) but with a JavaScriptish flavor. I developed the library based on my experience working on both SharpDevelop and HPE VuGen while considering the special requirements one may have when developing a web application.

The library runs both in the browser and Node.js, is fully documented and has ~100% coverage in unit tests. Feel free to star/fork it on GitHub.

Considering “Conway's Law” as an axiom, I aim to consider several aspects of how the organizational communication structure effects software design. Rapid changes within cross-timezones organizations influence software architecture processes. What can engineers or architects do to guarantee a productive and quality assuring design and implementation process, that foresees ongoing organizational changes. Organizational changes are another requirement of the design and implementations of software system.

One of the most popular topic, which people in the hi-tech industry, like to talk about is: Hiring.

Ever wondered what makes this topic so sexy and common? Well, it is the most important thing in building your engineering culture. You must have the RIGHT people, in order to be able to develop the RIGHT things in the RIGHT way.

The thing is, that reality tells us, the most companies are failing in recruiting the right people.

If you look on the best companies in our industry, the ones that have the best people working for them, like Facebook, Google , Dropbox and others, you'll find out that the recruiting process in them is not the same, to say the least.

So what is the secret for recruiting the right people? Is there even a single answer to that?

Well, come to my presentation and you'll find out...

When building software to perform a specific function, engineers mostly focus on design and implementation. I aim to show the advantages of a process of design that begins with thinking about what is expected to occur once the software works, and that integrates measurements that examine the achievement of these expectations. Measurements should be comprehensive, and relate to product oriented expectations, software design expectations and software performance expectations.

Management Blues is a thing! It's often not easy being a manager - too many responsibilities, not enough clarity; lots of stakeholders to satisfy, very few true friends and mentors to consult. This can cause stress and sometimes even the blues.. Many tend to dismiss it or just refrain from talking about it in the hope that i'll just go away, but not handling this issue can be destructive to you, your team members and your company.

In this talk I will describe my personal experience with the Blues and signs to identify that you're actually having it. I will also discuss preemptive measures to avoid it and suggestions on how to overcome it.

In this talk we will delve into one the biggest challenges of front end development, Test Automation. If you think unit testing is hard, getting started with end to end testing is horrific. The ramp up huge and the maintenance is hell. In this talk Oren will walk the audience into this world, starting with the differences between writing Unit Tests, show how to deal with asynchronous challenges, delve into UI validations, provisioning browser instances, and most importantly, creating robust tests which work in high fidelity while your app undergoes daily changes.

On September 2007 I started a journey. I left a position as a System Architect in a big Software company and started a career as an independent consultant. This have been a hell of a journey, and now a year after I returned to be an employee (business was doing great btw) I wanted to share with you some of the insights I acquired along the way. What worked for me, what was challenging and where I think that I could have done better. I believe that anyone who considers becoming an independent contractor/consultant will greatly benefit from this talk.

Sometimes writing code is not the main challenge of an engineer. Engineers today should have great communication skills in order to bring a colleague to a complete understanding of a complex system / idea. In this session we will try to follow concrete real-life scenarios and analyze the DOs & DON’Ts of how to deliver such thoughts from one engineer to another.

Pivoting is a known practice in the startup world. Easier said than done, switching a direction of a company or a department has many aspects - from code and archithecture, through managing customers, all the way to working with investors. Most startups do 2-3 pivots before they succeed or die, usually losing some key players in each pivot. This session will focus on the People Aspect of doing a pivot:

• How to keep people motivated (and stay motivated yourself) through a pivot?
• What are the key positions you need to keep an eye on?
• How do you quickly stop doing what you did, and start doing something different, without losing the trust of the team? and more...

Target audience: everyone that might be part of a pivot - you're probably one of them, even if you don't know it yet :-)

When I suggested to my boss that our new project should be written in a functional programming language my idea was bluntly refused. But still, I went on and started a journey to learn Haskell, a purely functional, strictly typed language. Only a few miles down the road there are already beneficial ideas we can bring back to our more "conventional" languages such as Python and JavaScript. We will meet some of these ideas presented in familiar languages.

Improving the way an R&D org is working is a bit like refactoring of code. But it requires dealing with changes not only to the design of the code, but also to the culture, processes and habits of R&D, Product, and QA. In this session I'll walk you through such a journey we did in Perion. How we applied an Agile way of thinking (and not just the ceremonies), improved the architecture, used better tools, and more. Eventually getting to a daily release schedule.

Target audience: R&D Managers, Product Managers, Project Managers

Every time a mathemagician starts talking about monads they leave the familiar world of worldly working programs for the magical realm of category theory.

How they're being used? Why people other than Haskell programmers should care?

Have you ever developed an open-source project?
Are you the only user?
Me too.
But I am still trying to get developers use and get involved in an open-source frameworks. I will share what channels are working and what isn’t.
I will talk about previous failures to do such efforts from my side and will analyze why frameworks succeed? Is it mainly marketing and PR?
In the talk I will expose my new secret-super-awesome-dumb-useless-framework and its fork count.

There is a gray area between Dev and DevOps ownership, that can easily lead to blame games, finger pointing and eventually slow down the resolution of production issues. This session will provide real-life examples on how we prevented such issues at Perion. We did it by applying the SOLID principles to the tools, scripts and processes that we developed. You will learn how to implement those principles to CI / CD / Production Monitoring and more.

We all know we should be writing unit tests to test our code; We've all heard of the marvelous benefits of Test-Driven Development; We're all deeply embarrassed by our low code coverage, poorly written, broken, or non-existent tests; Or at least we should be.

But why?

For nearly two decades our work has been constrained by the CAP theorem, forcing engineers to choose consistency over availability, performance over correctness, scalability over simplicity.

No more.

Here we will introduce the results of years of painstaking research, careful development and methodical benchmarking, showing how you can run... unCAPped.

:הרצאת לא טכנית, מלווה בהומור. ראה

Tearing Down the Protocol Wall given at SDN4FNS

:תקציר בעברית

מדוע פרוטוקולים לתקשורת לא נחשבים לתכנה שיכולה להתפתח בחופשיות ולעומת זאת נראים בעיננו כ״מאחורי חומה״ המונעת שינויים בחופשיות? דמיינו שכל שינוי בתכנית היתה צריכה לעבור אישורים של אין ספור ועדות תקינה. המשמעות היא שמתחת לבלטות המבריקות (המכונה ״תכנה״), נמצאת צנרת מיושנת וחלודה (פרוטוקולי תקשורת).

נראה כיצד מציאות זו יכולה להשתנות ואיזה תועלת תביא בעקבות השינוי, לא פחות מסעיר מתפיסת קוד פתוח עצמו.

Abbreviated abstract:

"Protocol Wall" is the artificial barrier between the inflexible, protocol-bound communications space, and the application space in which far fewer constraints are placed on the programmer and in which far more innovative results can be achieved. Overcoming the Protocol Wall allows fully programmable, software-defined behaviour in both the data plane and the control plane, and opens the way for much-needed innovations in networking.

Full abstract

Together with two coworkers of mine (and the graphic assets provided by my wife), we decided to develop an iOS application with a really simple idea - serve a nice TV Guide for Israeli TV.

This trivial and no-way-it’s-going-to-work idea, that was developed as a side project after our working hours, has suddenly brought us to the first place in the Israeli App Store. Thus, exposing three developers with no prior customer-facing experience to more than 100,000 users.

In this talk I would like to share the journey we have passed, starting with the doubts in the beginning, what made us go for it anyway, the challenges we faced, the fun parts and eventually what brought this journey to an end.

העולם נעשה שטוח, אורך חיי המוצר קצרים ומתקצרים, יש לחץ על חברות להביא ערך מוסף למוצרים שלהם באינטרוולים קצרים של כ 6 חודשים. מי שלא עומד בקצב, הופך להיות בלתי רלוונטי בשוק תוך שנה וחצי אז איך קרה שיש כאלה שעושים את הקסם של חדשנות ויש שלא?!

OpenDaylight (ODL) is an open source platform for Software Defined Networking (SDN) control applications. ODL is written in Java and used for management and control of various kinds of networks, with emphasis on virtual networks controlled by industry standards of OVSDB and OpenFlow. In this presentation we will present the fundamentals of SDN and Network Function Virtualization (NFV) and describe the general architecture of ODL in this hot networking space.

In this session, we’ll introduce the holistic approach to running native client automations with your existing Webdriver-based web test suites. This presentation can be used as a guide to go from no mobile automations to a formidable native automations suite that runs on a daily or hourly basis. The technologies and tools in the presentation include (but are not limited to) the following: Appium, Cucumber, Watir, Jenkins, Xcode build script, Gradle, and Cocoapods.

Introduction to the new (ionic based) Farmers protest application - מהחקלאי The application helps connecting farmers who sell directly to the customers. It is built with Rails 5 API as a backend and Ionic framework for Android / iOS apps. (and I need your help !)

From Sharepoint to Drupal My personal story of how I have helped gov.il in examining and using open source software. How it started, the struggles with commercial companies, Drupal to power gov2.0 (and how המחאה החברתית helped in pushing this forward)

When we seek information on the web, we use search. We state our intent as clearly as possible, and get a list of links that is likely to satisfy that intent. When we recommend content at Outbrain, our users lack an explicit intent, but they do have implied interests as reflected by their browsing patterns.

This talk is about how we reduced the problem of recommending content to a user, to a search problem for users’ implied interests. Why is this analogy interesting? Because it allows us to use state-of-the-art distributed search platforms to solve some of our major scale bottlenecks, and to increase the complexity of our online prediction models.

We will talk about incorporating Elasticsearch into our serving stack and using it for filtering and online scoring of content recommendations. We will talk about the way the content marketplace rules and restrictions are translated into Elasticsearch filters, and how we use dynamic scripting for our Elasticsearch scoring function. We will talk about Elasticsearch limitations in terms of both indexing and retrieval, and our attempts to overcome those limitations.

In this session, you'll get an inside look at how the Red Hat Quality Engineering team has used Red Hat Cloud solutions to implement a continuous integration (CI) system for the development and QA of Red Hat products and solutions. We'll show how OpenShift Enterprise by Red Hat, Red Hat Enterprise Linux OpenStack Platform, Red Hat CloudForms, and Red Hat Satellite can be integrated with the Jenkins continuous integration platform to decrease cycle time and increase test efficiency. You'll learn about:

• The continuous integration architecture with Red Hat cloud solutions and Jenkins CI
• How to trigger on release a nightly build and release candidate
• Methods to perform automatic image preparation
• Provisioning test servers and containers
• Considerations for testing tiers in development and QA processes
• Automated documentation creation
• Test result automation with JUNIT for integration with management software
• Log analysis
• Generating code quality metrics
• Automated software build installation

I will share our internal Product Process, from Prioritization to Production. Sharing our insights, list of tools, and how it helped us along the way in the critical junctions our product development. We will learn about good vs. bad processes, necessary changes and how to deal with missing links in your product development chain

US Real Estate market has a unique, traditional trade mechanism, that hasn't changed much since the mid 19th century. Home discovery has become easier with new technologies, while the core transaction mechanism remained. Everyone agrees that billions of Dollars can be saved and put back into the economy, instead of being waisted on obsolete players. By 2020 the disrupt is expected to be prominent, and within 20 years the whole market may be way more efficient, technology driven and buyer/seller centric, instead of broker centric. What are the trends? Who are the main players? Where is the competition? What technologies can cultivate the disruption?

• Introduction to the US Real Estate market - 15 min
• Current technological ecosystem and solutions, current disrupt status - 10 min
• Technological and mechanism innovations to support a disrupt: automated bidding, document signing, financial automation, home automation - 10 min
• Q & A - 5 min

Starting w/ MongoDB is easy and setup an alwsys-on cluster in under 10 minutes is common. But how far can you grow w/ it? In this session we'll explore common pitfalls and best practices to grow your MongoDB datastore and meet your business goals based on actual cases from the Israeli high tech and startup scene.

This event will cover the Microservices architecture journey, that are currently getting a lot of attention, of splitting your application into set of smaller, interconnected services using the guidelines and techniques that are leading to significant benefits – especially when it comes to enabling the agile development and delivery of complex enterprise applications https://www.youtube.com/watch?v=0QO95GfTAaE

Investor's demo in two month and no replies from Drushim yet? It's time to outsource! What should you know before starting? I'll tell you five stories to learn from and never get in a trap yourself.

Years ago advanced A.I. was used exclusively by the giants companies like I.B.M (Deep Blue), Google and such. Then the open source empowered the small companies and they were able to use Machine learning algorithm and Big Data platforms, mainly in the recommendation and prediction area. The revolution continues and today with GPUs (graphical processing units) and Deep Neural Networks open sources one can use his personal computer and achieve state of the art applications that can learn to win games, detect images, sound, viruses etc. In my presentation I will overview what is Machine Learning, what is a Neural Network, why it is so revolutionary and for what applications it can be used. I will dive into one of the best open sources in deep learning while presenting several models and fished with some personal lesson learned.

The foreman project (https://theforeman.org) is a major open source project (7 years old) that is widely used in the world of infrastructure automation / devops etc. I would like to do a short intro to the project, and also share some of the challenges above when managing a large scale project over time.

Sometimes video is not just video. The web allows us to enhance video experience with user interaction - hence interactive video. No matter the narrative, whether you're making a movie, a game or an ad on the web with HTML5 video: one aspect is always important: The GUI. So what is interactive video and how can you layout amazing interfaces on top of video with web technologies like CSS and SVG, and make it work across devices and platforms without affecting video performance? I will show many cool examples, present several methods of achieving just that, discussing best practices and highlighting the advantages and disadvantages of each.

By now, everybody knows open source, but sometimes its hard to keep track of whats going on, large open source software projects are usually complex to join as a contributor, in this talk, I'll try to shed some light on how large projects operate and where can you get involve.

This talk should cover things like communities, release management, developer happiness, guidelines, common pitfalls and everything else that makes an open source project successful.

What if you could create a world? How would it look like? What creatures would find place in it? And what would happen when the creatures from your world meet those of another world?

“Telluric” is my thesis project created in the Bezalel Academy of Arts and Design which experiments and tests those exact questions. In this multiplayer game/experience users witness firsthand phenomena such as mutation, death, natural selection and evolution. In this talk I will present the project, created entirely in ThreeJS along with a technical breakdown of its different components. I will touch on topics such as custom shaders, animation, modularity and multiplayer communication.

Firebase is an amazing service that allows you to create real time data sharing in JS between multiple clients. Phaser.io is a javascript library for making games. I’ll be live coding to show you how to use Firebase & Phaser.io to create a multi-player game experience in the browser. Audience participation is both mandatory and fun!

Front end development is becoming increasingly complex. In the past you could just serve your CSS, JS and image files and you were good to go. Nowadays you have Single Page Apps and modules and assets and images and libraries and frameworks and oh god what now what. Let me help you with your Analysis Paralysis. I went through all the options for modularizing, bundling and serving your code so you don’t have to. I’ll explain the problem and present current solutions like Require.js, Browserify and Webpack, their use cases, their merits and their faults so you could stop worrying and start coding

How can you make your site feel less like a static page and more like a video game? In many ways modern web sites are similar to video games: They both offer engaging interactive experiences. They both also often encounter the same difficulties like performance issues, adjusting to different screen size and device fragmentation. In this talk I will show how to apply video game principles when designing and building websites. I’ll also present Javascript/CSS libraries for particles, physics, camera movement and interactive video so your visitors can stop watching passively and start playing actively!

Sharing tips and tricks for raising early stage funds in Israel and beyond. We'll quickly cover some basic terms, but try to focus on insights that aren't widely available online.

Examples and challenges in the build-measure-learn cycle as it meets various real-life scenarios. For example - building an MVP in the mobile era when customers are expecting out-of-the-world experiences, short cycles with Apple review times (and when all your reviews get wiped away), what to measure and what not to measure, and more. Don't expect absolute answers, but hopefully interesting considerations taken from the JoyTunes journey.

This talk will cover different aspects of being featured in Apple's App Store: process, technicalities, inside tips, opportunities and challenges. We will share from our experience after being featured many times, including on the App Store homepage in US and China.

After the huge success of the JTLocalize song in RS 2015 (https://www.youtube.com/watch?v=mfUTa3tlJ4M), I plan on performing with a new song, summarizing all the big new things in the past year in the mobile development world in a fun humorous way.

There’s an old saying that “knowledge is power” and as a developer I couldn’t agree more. Knowledge is everywhere, and it’s extremely easy to learn and consume content online, but when it comes to people in your company (and especially developers), which have different tasks, timelines, and teams, sharing knowledge become almost impossible.

Well, there’s a solution for that and in Outbrain we call it “FEDs forum” - which is basically a periodical meeting for all of the Front End Developers in our company.

In this session I’m going to talk about the forum, how it works, what are we doing there, what’s so good about it, and how you could start one of your own for developers in your company.

Staging environments could help you run integration tests and save a lot of pain before deploying to production, but could also become a nightmare in supporting the architecture. I'd like to talk about stagings pluses, minuses and requirements (of not getting mad) for different flows of devcycle.

As part of my PhD, I am developing a new visual programming language for web service orchestration.

As Fred Brooks (the mythical man-month) once said: "A favorite subject for PhD dissertations in software engineering is graphical, or visual, programming - the application of computer graphics to software design.... Nothing even convincing, much less exciting, has yet emerged from such efforts. I am persuaded that nothing will"

But after 30 years, maybe things have changed?

I would like to share with you my progress, vision, and of course, many many pitfalls :-)

Devops & system infrastructure worlds are evolving fast, with the plethora of cloud services with extended API capabilities. Every action can be coded and automated. All you need is someone to code it:

So why do u still write it all in bash/shell scripts?

1. It works!
2. This is the fastest way and I don’t have time.
3. This is what my sysadmin know.
4. It works!

In Kenshoo we write infrastructure code mostly in Python. Code is written as proper production code using the common practices of testing, CI, Code reuse and SOLID principles.

What for? How come? Come and listen…

Sessions Key points:

1. Why most high level programming languages you know would be preferable over bash.
2. Why your bash excuses(above) are pointless.
3. Tips & tricks in writing proper infrastructure code (Stick to one main language for instance)
4. How writing your infrastructure code like any other code will actually reduce your ops cost.

Today’s Devops tooling and ecosystem requires enhanced coding capabilities from your team members. But what do you do when you have a team of Sysadmins that are used to work with manual IT procedures and write bash at most?

In this lecture I will share the steps taken in Kenshoo to transform our sysadmins & automation engineers into infrastructure developers. For some of these employees this meant a major philosophy change. I will also add tips on how to tackle specific personalities and common misconceptions in these types of employees.

Sessions Key points:

1. How to deal with the different IT/automation personalities and concepts.
2. Necessary steps to transform these employees to developers (courses, code reviews, pair programming, code retreats).
3. How to compose your devops team.

How many times do we ask ourselves this question? what is good enough? others might call it - what is the MVP?

In the session, I will cover some key questions and guidelines on how to decide what is MVP, including examples - all in 5 minutes!

We usually say that people look like their dogs, and we tend to date people that look like us. Is it possible that the same rule goes for our programs and apps?

As a UX designer I help customers creating their desired products, and I find that understanding my clients is the one of the most crucial steps in designing the product they have in mind.

In this talk we'll see what are the main things you should understand about your client, and how to use those things or deal with them while designing. And if you are designing your own product - how are your personality and attitude reflected in it? Is it good? bad? Can you do anything about it?

Using Docker we can take tests, pack them into a container and ship that container to any environment in the world. It could be a simple test that check that my host clock in on sync, it could be a security scan, it could be your application acceptance tests - write once deliver anywhere. That is power!

But, who is going to run the tests? How we will get a unified quality picture?

Docker has a unified api across any container, that feature enabled use to build tugbot .

tugbot is co-located in the app env, it can automatically discover test containers, run them periodically or on change event, collect the results and publish them to a centralized result service.

Create a test container integrated with tugbot is deadly simple. 3 lines to make it a docker container and 2 lines to integrate it with tugbot .

Tugboat is a vessel that brings shipping containers to a safety land. 'tugbot' is doing the same for test containers.

tubot ppt

tugbot in github

LAMP (short for L inux, A pache, M ySQL and P HP) is a famous open source development stack that served as many developer’s gateway to programming.

In this session I’ll attempt to show why I think taking your first steps in coding using LAMP is a great way to pick up bad habits, and how it's our responsibility as managers and mentors to make sure that defects in the stack we use won't turn to defects in the programmers that work with it.

Ever heard of a "Quine"? A Quine is a program that reproduces itself. Basically - it takes no inout and produces its own source code as the output. Sounds tricky? Let's learn how to write one in Ruby in 5 minutes!

For the past two years, the production engineering team at Similarweb has gone through a dramatic makeover. We had to redefine how we collect, monitor, visualize metrics and cherry-picking what should wake us up at night. In this talk I'll describe our journey as a team, the decisions we made, the goals we tried to achieve and the tools we ended up using.

Chat bots are the latest AI trend, featuring bots that do anything from ordering flowers to being your lawyer.

In this session I will present a content chatbot and how it is built.

The synergy between NLP, search and Outbrain's recommendation algorithms enables us to understand the user’s information need from the chat, and respond with relevant and timely content.

These play together in building a user friendly bot, where one can get the latest headlines, receive user-specific recommendations, and ask in natural language about specific topics or categories such as “Donald Trump” or “Sports”.

The talk will describe how within a few weeks we took the idea from inception to being demonstrated by Mark Zuckerberg in his keynote in Facebook’s Developer Conference. We overcame the technological and algorithmic challenges in developing the content bot, yet are still surprised by some of the bizarre inputs users enter in the bot, some of which we will share.

Creating a good shopping chatbot must be about something other than a long series of questions around the exact features of the product you are looking for. It should be about helping you find what you are looking for -even if you are not sure what it is, using something most of us are influenced by - social buzz. Social buzz helps us make a lot of decisions and making it part of the shopping experience is crucial for a chatbot to become successful and engaging. However, extracting the correct buzz in a scalable and real-time method is not so easy. In this presentation, I will talk about how does a small start-up with limited resources extracts all the relevant buzz for its chatbot-as-a-service product using technologies like Machine learning, NLP, Apache Spark, twitter streaming api, noise filtering algorithms and the facebook messenger platform.

The presentation is based on mmuze's chatbot - demo is available on our website.

Agenda:

1. About me, mmuze and video of the chatbot experience
   
2. Social buzz - how to extract it from twitter?
   2.1 Getting all the data we need
   2.2 Filtering out noise
   2.3 Creating trends using Scala - clustering buzz around celebrities (using Apache Spark)
   2.4 Tagging trends for chatbot's usage
   
3. Chatbot integration
   3.1 Short intro of the architecture
   3.2 Integrating trends data into chatbot experience
   3.3 Learning
   

I have been a developer for about a decade. Despite always wanting to contribute to open source, it took me a very long time to finally get around to it, and I encountered various difficulties along the way. This presentation will describe them and provide advice to make those first baby steps easier.

Everyone talks about "Functional Programming" nowadays. However, there is a huge misconception around it. Moreover, discussions about functional programming tend to involve the "Monads" and many can't quite grasp their meaning. In this session we'll go into "What is Functional Programming?", why, where and when can we embrace it and what exactly are the infamous Monads?

MyHeritage is home to more than 7 billion (and growing at a rate of many millions per day) unique pieces of information about people spanning over many generations. We run many algorithm to enhance the data on a daily basis, finding new insights about our data and giving our users answers to questions they haven’t even asked yet. The scale of this task presents us with many challenges…

Adam && Eve, David && Jonathan, Hansel && Gretel, Jordan && Pippen, Messi && Neymar (&& Suarez) Shimshon && Yovav, Rega && Dodli : History is full with pairs that created a true synergy between them. Ownership && Quality are just another “power couple”.

We wanted to improve the success ratio of our Automation Production Test. We started with constants measurement, moved to clarifying the ownership and gained significant quality improvements. I will describe the process, the tools and the change in culture that brought us to improving quality and better ownership.

PureScript is a relatively unknown purely functional programming language that transpiles to JavaScript in a straightforward manner.

In this lightning talk, I will try to make a case for PureScript: why it exists, why it's interesting and why you should care.

"Mundialito" is an open source application which allows you to create a contest between you and your friends on soccer games. It is one-click deploy-able so everyone can easily create their instance and play. It has an responsive web application and a nice admin view.

https://github.com/ezraroi/Mundialito

ושוב מגיע טורניר גדול

וכולם פה רוצים להמר על הכל

חיש מהר נקים אתר בשחקים

שבו ינחשו כולם תוצאות משחקים

(By @Zivry)

I've spent most of life amongst storytellers in journalism, stage and screen. I've spent the last two hiring and working with great engineers at Wisdo.com. It's my profound belief that great code writers are artists in soul and practice and that the architecture of stories can and should be taught to those who spend more of their days - solving stories rather than writing them. Code needs to serve a greater purpose. Stories provide that greater purpose efficiently. Finally, engineers who want to take the leap and become co founders - will need to know how to walk into a room, and make that room listen. There's a shape to that that can be taught.

Never has there been an industry so riddled with solutions as the web development world. For every single corner of your web application, there are literally hundreds of different approaches, solutions, libraries or frameworks. These may or may not fit your needs and we spend a lot of time reading through tutorials, instructions, examples and stackoverflow questions. More often than not, we reach the frustrating conclusion that the best thing for our application is to build our own tailor-made solution. In this 30 minute talk, I would like to share a few stories from our team at FDNA. In these case studies, I will cover interesting aspects of these stories such as involving team members in the decision making process, the time and space for these processes in an agile environment, and the importance of committing to the final decisions. Through these experiences we learned to better understand our needs and find solutions quickly with less hassle and headaches.

We all agree that recurring operational tasks are time-consuming nuisances, which should be eradicated using automation. However, sometimes they require careful coordination, hardware manipulation and worst of all - human interaction.

Recently, we found that our code doesn’t really need to pass a Turing test in order to successfully interact with humans, and convince them to partake in an automated process. In this talk I’ll describe how we automated disk replacement for our HDFS clusters - despite having to communicate with the hosting provider by emails, while preventing the process from failing at scale.

Good visibility of a system is one of the key factors in being able to maintain high scale, robust and stable data system containing dozens of clusters and hundreds of nodes across multiple data centers. One would expect that for highly popular open source systems like Cassandra, there will be tons of documentation and open source projects to expose its’ metrics, but this is not the case. In this session I will talk about the challenges we faced in Outbrain to achieve better visibility for Cassandra and how they drove us to build Cassibility - a Prometheus and Grafana based visibility package for Cassandra that we chose to develop and outsource. I will describe the different components and dashboards and how we use them.

Who doesn’t know the feeling of hearing about the latest 3 coolest technologies just released, which you just realized could be the best fit for your organization current challenges or give the next generation capabilities to your systems? In today’s world, that’s the feeling many of us get very often, and as a result, especially in very technology focused organizations, many technologies are introduced within a short time, while the older technologies are still there, and the R&D and Operations groups should support it all. But how do you keep up with the newest technologies and choose the right ones? How do you manage to be agile but still have have a broader look? Who should own all these systems? I’m going to cover all of these issues in the talk and suggest a process and ownership model we’re implementing in Outbrain.

Static Analysis is a very effective tool to improve code quality. Integrate it into the code life cycle requires both your cultural and technical attention.

In this talk I will show horrific examples of what we have found in our code base, and the process we did taking FindBugs from a P.O.C into a one of the main pillar of our Immune System.

Node-Chakra is a fork of node.js that replaces node's JavaScript engine (Google's V8) with Microsoft's JavaScript engine - Chakra. The project was open sourced a year ago and received very good reaction, with the node community taking the project under it wing as it currently lives side by side with the node.js project as part of the official node.js organization. In this talk I will describe how this project was created and built, and how it was possible to successfully replace node's JavaScript engine, a task that many people considered to be impossible up to that point.

Java prides itself in not allowing you to shoot yourself in the foot, but doesn't always live up to the hype. Recent editions have introduced powerful new syntactic tools which make development much easier, but can often result in "WAT" moments.

This lightening talk, inspired by Gary Bernhardt's famous WAT talk will showcase some of the cases where Java has left me scratching my head and asking "WAT?".

Releasing code 30 times a day to production introduces all sorts of challenges from a Quality perspective.

In this session we will discuss: How do we test? When do we test? Automation? Manual? Regression? Progression? Performance? Monitor? Alerts? Cross platforms? APIs? And more...We will explain how we release high-quality products to our users all the time.

When you have a web app owned by several teams - very soon you will need to handle issues like: quality, ownership and autonomy. Using the “micro services architecture” hammer is not that trivia when your nail is a monolithic web application. How do you handle: session management, security, cross apps links and user experience ?

In this talk i will describe how we did manage to solve most of the issues, and ended up with smaller web apps (aks microApps) running a modern technology, with full ownership and autonomy.

MyHeritage is home to 82 million users with 2.5 billion rich personal profiles in their family trees, stored on complex and highly optimized MySQL infrastructure. As we started encountering scalability and performance issues, we have built a new data store, based on Cassandra, Mesos+Docker, and Hadoop , that is highly scalable and blazing fast. In this meetup we will share the architecture, design considerations and lessons learned. Among the complexities we will cover is the challenge to load the system while data is changing, keeping a MySQL source-of-truth and Cassandra in synch, errors handling and monitoring.

Well, maybe not all of them, and perhaps not forever...

Production incidents -- " The application is down " -- are the worst nightmare of any web startup. They not only ruin customer trust, they are a time sink for a development team that needs to focus on improving the product, not keeping it running.

In this talk I'll share 5 practical methods we used at Totango to reduce production incidents, from a few incidents every week to (touch wood) rare occasions happening a month.

Specific items I'll discuss:

• which metrics to use to track production incidents and how to measure them
• using slack and statuspage.io to report and manage incidents
• how to conduct effective, blame-free RCA
• tips on communicating incidents to customers

With big data comes big challenges, and in this talk we will cover the following topics: How cross R&D continuous deployment and R&D structure supports scalability, sharding techniques, Cassandra usage at MyHeritage, our search engine scaling structure, few other related technologies used by the Back-End to support scale.

You might be asking yourself, “Another presentation about Continuous Deployment (CD)?” Well, the answer is Yes and No: yes, this presentation is about CD, no, it’s not just another CD presentation like you’ve heard before. We will discuss the unique CD implementation we have at MyHeritage, which includes Canary testing, all developer work done on a single branch (“the trunk”), BOTs integration as part of the deployment, production update events reported to our monitoring systems, exposure control, and more.

If you start a new software project tomorrow morning, itll almost certainly be open source. However, 10-15 years ago, before GitHub ruled the earth, that was not the case, and mature products find themselves in a disadvantage when compared to new open source rivals. So - How do you turn you project inside out and open source its core? What technical challenges arise, and how do you confront them? How do you decide what should be open sourced and what not? Once you've decided, how do you estimate it and refactor it? And lets not forget your existing customers, which expect a smooth transition... Is that even possible? Yes! - Join us as we share stories and tips from our journey of taking a 15-years old product to the Open Source era.

Having an enterprise as a user/contributor to an opensource project is a stamp of approval of your project's maturity and market reach. In this talk I will unveil the typical behind the scene of enterprise opensource adoption and give some veteran tips on how to make adoption (and in the way customer acquisition) much easier.

We will talk about:

• how enterprises evaluate software lifetime, maturity and risk
• Who are the stack holders in software adoption in enterprise
• How to pitch and copy-write software product for easy enterprise buy-in

So you want to speak at a conference, or maybe a meetup - but you're not sure how to start, or perhaps you think you suck at it. Well, I’ve got good news for you: giving awesome talks is an acquired skill, anyone can give great talks! (if they put their minds to it) In this talk i’ll share my experience and insights on how build and deliver talks at conferences and meetups.

BioCatch is a leading provider of Behavioral Biometric, Authentication and Malware Detection solutions for mobile and web applications. Available as a cloud-based solution, BioCatch proactively collects and analyzes more than 500 cognitive parameters to generate a unique user profile.

In order to cope with thousands of concurrent requests each with a strict low response time, together with massing and analyzing TBs of data, Biocatch together with Microsoft crafted a new architecture and adopted cutting edge technology to support their most demanding workloads for their customers.

We will deep dive into how BioCatch moved from C# based PaaS Services into a Python, Docker based DevOps process, while utilizing Apache Mesos for container orchestration.

Moving away from traditional Dev - Build - Test - Deploy to a Dev - Deploy - Test mode of work using containers have reduced deployment times from more than 15 minutes to a matter of seconds.

Finally, we will show how BioCatch enables a strict SLA for Big Data analysis and near real time event ingestion using Apache Spark on a DCOS enabled Mesosphere cluster, making use of Mesos as a Spark Scheduler instead of YARN.

There are only two kinds of companies: The ones that have technical debt, and the ones that out of business.

Dealing with technical debt is an expertise each engineer and manager should have. Our day to day work requires us to be able to build new products and technology while keep old ones robust and updated. Keeping this delicate balance is not an easy task.

In this talk I will describe the techniques we are using in order to manage our technical debt. I will share real life examples for both success stories where we reduced our technical debt, and cases where we failed.

Serving millions of requests per minute, across multiple data centers, in a micro services environment, is not an easy task. Every request is routed to many applications, and may potentially stall or fail at every step in the flow. In the lecture I will cover some of our most effective ways to tackle common issues in such environment which led us to build a stable system with low latency and high success rate

When SAP was facing the challenge to renew its complete user experience, there were more than 100,000 business applications written. In actual code, not template-driven screens.

This talk will look at the steps we took at SAP to get an award-winning business application design and implementation. We will review the new "Fiori" SAP UI infrastructure - From UX guidelines, UI libraries and UI integration framework.

Choosing the right vendor is critical for your success. But what is the right vendor for you? What would make a vendor "awesome"? and most important what does the chosen vendor means about the culture you want to build in your organisation?

During the past year @Outbrain we addressed this matter on different levels (data center facility, software network, dynamic acceleration and more) and will be happy to share our war stories.

In a very short time, Microsoft has shifted a lot of its focus from building enterprise and license based products to enhancing support, development tools and its knowledge base surrounding OSS platforms, a move unthinkable a few years ago.

This will be a short talk about the efforts Microsoft is putting on building relationships with the OSS communities covering the new teams sprouting inside Microsoft world-wide, that are responsible for communication with the OSS community, publishing OSS projects, working together with startups inside and outside of Microsoft Accelerators to find and conquer technological challenges.

This short session will cover real-life examples of collaborations with humanitarian projects and start-ups in the fields of genomics, drones, robots and others.

Azure web jobs on steroids - Focus on logic and forget the rest. The talk will focus on using Azure Functions for easily connecting between services, building pipelines and building connected cloud workers.

The features I will be focusing on:

1. Queue, Blob, HTTP, Web hooks and Schedule triggers for input and output
2. Simplified logic model
3. Simplified UX for management
4. Online editing, executing and monitoring
5. Full support for Node.js, Python, Bash, Php
6. Combine with existing web app functions like Continuous Deployment, Scaling, Analytics etc...

In this session we will talk about how Spotinst is using several types of differnet prediction algorithms to get maximum accuracy of Instances uptime and pricing inside Amazon & Google Cloud.

We will also talk about the next generation of Nested Virtualization and the concepts of building a Virtual Cloud as a derivative of public and private data centers around the globe.

I would like to share our recent experience of integrating very large datasets of users who belongs to external providers with Outbrain’s internal system. On our way to achieve that we had to integrate events consumption via SFTP, internal processing in Scala with it pros and cons, and distributing the events to Hadoop and Cassandra.
Among the main challenges are the scale (Hundreds Millions of user events per day) and architectural considerations to answer requirements such as: how to recover from errors, configure audience recency, what and how to measure etc’.

איך שטים בים של רבבות אירועים
המגיעים מכל מני צדדים
פותחים מפרש עם ציור של פיל
ואף נבואת זעם (של קסנדרה) אותנו למצולות לא תפיל
אז שימעו נא זאת רבותיי
כי ככה אספתי את כל עוגיותיי
... (by @zivry)

Did an error in your React app generate a stack trace that meant nothing to you? Ever wondered what's going on behind the API?

React pertains to do several things very well, namely componentization, performance and data flow. Most knowledge about it in the community revolves around usage - API's, add-ons, and data flow implementations. But very little knowledge is being openly debated as to how React does what it does.

In this talk I will inspect from close range the different object types and mechanisms used by React, practices of code, and the debugging process of a React app.

Many system are built over messaging frameworks (some of them listed queues.io/ ).

One of the most important metrics is how many events per second your system can handle (throughput).

I will explain how to arrange the topology of your queues so it will improve the performance of your application. There are several simple principles which should be followed. Using those principles we more than doubled our throughput for our application.

Pandas and Sci-Kit learn are powerful open source data science and machine learning toolkits. However, putting them into production is not as seamless as it could be. In this talk attendees will learn how to build, visualize and connect Pandas and SciKit learn ensemble models into an Azure ML pipeline for experimentation and production to solve a novel problem in the genomics space.

IOT and smart devices are for a long time the new cool kid on the block, and while combining the physical world to the digital world seems closer than ever, the difference between ‘embedded software development’ and ‘server side software development’ seems like the difference between day and night. But are they really that different?

In this talk I will share our journey to develop our first smart device - Alfie . And share how it changed our view on very definition of Full Stack Developer. Explaining why a web developer in 2017 should understand IOT,.

In the talk i'll share

• How you can develop your prototype and final product in JavaScript. and why hardware is not that scary.
• The power of 3D printing, self-fabrication and prototyping hardware to create effective Lean learning.
• How we keep being agile in an environment that is very unforgiving to change.
• How IOT development changed in the last two years, and how it becomes much closer to Full stack development.
• and finally we will talk about how Open source, open hardware, and the community slowly redefine who can be a hardware developer.

Let’s face it, building a successful software startup is essentially a gambling game. So how come our backlogs are still filled with users stories, like we actually know what the users wants?

In this short presentation I will explain how we turned our “agile” backlog to a data-driven backlog. Why we call our user stories “bets” (well… because they are). And how we built a system the helps us to create more calculated bets, and create features that actually have the chance to succeed.

and how this old Chinese proverb changed the way we prioritize our backlog -

If you must play, decide upon three things at the start: the rules of the game, the stakes, and the quitting time.

Chatbots and conversational UI are the hot thing for 2016, suddenly you can order an Uber with skype while running a deployment from slack and ordering a pizza with Siri.

In this session I will show how easy it is to expose your services as conversations. As we will build together a simple bot with node.js. We will talk about how to make your bots smarter by analyzing the meaning behind the text, and how to do it without having a large team of AI researchers using tools like Wit.ai and api.ai. and eventually see how we can create better experiences using hybrid UI.

But most importantly, I will share some of our experience on how to build a conversational experience that is actually good, and not just a novelty app that is eventually useless and annoying (clippy anyone?)

Let's discuss some "provocative" ideas in Software Development, that beyond being provocative - make some sense:

• Inheritance is a bold violation of OOP Principles.
• Duplicate code when you are not sure about the abstraction.
• Copy-paste as a legit method of code reuse.
• Git is not so good for you.
• You spend too much on Unit Tests.
• Reduce testing, and replace it with better production monitoring.

Microservices have recently became the "Default" Architecture style for modern systems.

Much like "MVC" or "Layered Architecture" styles before - many of us adopt this Architecture Style without deep understanding what problem this architecture came to solve (no.... it's not really about system scalability nor how to adopt Docker), nor about the cons and the costs it involves.

After experiencing the adoption of Microservices in Gett, and discussing with numerous people who did other implementation - it will be interesting to share some insights about MSA, where it shines - and where to be careful with it.

Detecting anomalies in big data sets is challenging, but rewarding. When you know to distinguish anomaly from normal - you know your data. In the presentation I will cover our, somewhat novel approach of anomaly detection in big data sets and explain both mathematical and technical difficulties applying it over big data sets. Our approach is about discovering statistical properties of the data sub-sets and finding anomaly ones based on it.

So you want to auto scale your services, and use service oriented architecture, eh? Want to reduce the cost of managing your clusters, and discover them dynamically?

In this talk we shall see how consul helps you do that very efficiently, demonstrate spinning up several interconnected services, and show how we can achieve seamless discovery, HA, and fault tolerance.

With the massive amount of textual data available today, it is a shame that most developers have very little idea how to parse and analyze text - especially considering the existence of easily-accessible Natural Language Processing tools (NLP). In this talk we'll build an application for analyzing traffic conditions based on textual feeds - from scratch! We'll see where we can get data and how cloud-based tools make this endeavor almost easy. Following this talk, you should be 'dangerous enough' to build your own ideas and dig deeper into the field that is NLP.

Packaging, integration, and deployment are problems every software company faces. Our dev-centric approach at Wix led us to build Lifecycle™, supplying engineers with the tools they need to independently build, monitor, and ship products. Lifecycle is one of the tools driving our ability to deploy hundreds of times a day across all development stacks, be it Scala, JavaScript, or even Python. Behind the dashboard UI, lays a set of interconnected services which the CI team has mastered. In this talk, we will introduce some of them, the challenges involved, and how we chose to tackle them.

Newborn babies are difficult. like your production system. this outlines everything from monitoring, services, analytics and such. humorous yet accurate.

The goal of the talk is to show the various steps and challenges required to build a full CI/CD pipeline from scratch using containers. The talk will include a full demo that will go over those steps from the writing of a small Python microservice, how to wrap it into a container, its continuous testing (unit and end-to-end) using the new Jenkins pipeline system and its automatic deployment on some cloud provider using Ansible. The talk will also mention the issues encountered during the pipeline building and how to overcome them.

Data services (e.g. databases) usually come with a long list of tuning options and there are tons of tuning guides. You have to tune the software for the hardware configuration, your workload, and your required SLA. The tuning encompasses the service itself and the OS kernel.

Your options are either to lose a lot of performance or a lot of sleep. This talk shows how you don't need to make that choice when your data service tunes itself to the hardware and to your workload. We will show how we built ScyllaDB, a NoSQL database, to perform at its best without any user configuration.

The talk will cover:

• cpu autotuning
• I/O autotuning
• automatic balancing among multiple workloads
• internal back-pressure between internal background processes

and more.

As programmers, we encounter stress in many forms: release dates, production bugs, hack even some code reviews can become stressful. I’m pretty sure that everyone got his share of stress while working in the industry and experienced some of its negative effects on his physical and emotional wellbeing.

The thing about stress is that it slowly creeps in and sometimes we are not even aware of it’s existence. Each person reacts to it differently: Some bite their nails, some have restless legs, some go visit the kitchen frequently (and you know how that ends). In this talk, I wish to cast a light on the everyday stressors that programmers experience and share my experience on using mindfulness as a method to become aware of, and eventually reduce stress at work (and some other techniques)

Writing mission-critical applications on top of streaming data requires high throughput, scalability and event processing without compromising “non negotiables” such as transactional consistency, and resiliency in a distributed computing environment. Kafka is becoming a default mechanism of moving data between layers. This can be observed in its adoption by Teradata, HPE, MapR with their respective ingestion layers.

A common challenge is how to manage the ingesting and processing of data while ensuring transactional consistency and meeting stringent latency SLAs for demanding throughput levels. There are several disparate approaches for accomplishing this using a combination of open source and proprietary technologies. In this talk, we’ll help you understand how a simplified architecture can deliver performance and reliability without the guesswork.

You will learn: How to make Kafka imports more actionable Ensure scalable, fully consistent data with synchronous command logging Meet low latency SLA requirements How to guarantee the aforementioned non-negotiables

Akamai is the largest CDN in the internet and we are leveraging the data for Security Analytics, needles to say the scale is a bit on the extreme side. At peek we handle ~10 Billion lines an hour and have over a Petabyte of data at rest.

Not all BigData technologies are really up to it, we have learnt this the hard way. Sometimes you need too rollup your sleeves and write some home grown technology to handle the tasks at hand. We have developed our own Columnar storage and are in the final stages of completing a solution to assist in Near Real Time query support.

Join us in hearing why and how and some real life stories of sleepless nights.

Search engine technologies (Lucene, Solr, Elasticsearch) have poor support for Hebrew out of the box. מה לעשות, עברית קשה שפה. The only way around this was to create a custom Lucene analyzer that is smart enough to disambiguate Hebrew words and manipulate the index accordingly.

Today HebMorph is being used by many users, some under an OSS license and some under a commercial license to support the future of the project.

After several years of working with Elasticsearch and consulting many clients world-wide, it's time to share some trade secrets and lessons learned.

Elasticsearch is an open-source search engine server, which is easily scalable and being used by too many companies to mention for search and real-time analytics and log processing.

Come to learn about how Elasticsearch is used, what are the absolute no-no's and what are actually quite nice and innovative usages of it. I will also share useful pro-tips and a handful of takeaways you could apply to your existing (or future!) deployments of Elasticsearch.

Automatically testing and monitoring your service & its availability is a big challenge. It’s even a bigger challenge to test your service when the websites that use it aren’t yours .

In this talk we’ll discuss few methods of monitoring your service, its availability and its performance strictly by testing (using Selenium) 3rd-party websites that use it. We’ll talk about how can you create alerts that won’t wake you up in the middle of the night for no reason.

The talk will also include a short introduction to the ELK(Elasticsearch, Logstash and Kibana) stack and how to use it to process your tests’ results at large scale.

• What are micro-services?
• The good and the bad parts of applying a microservices architecture (spiced with real world examples)
• Common needs of a microservice (authentication, rate limiting, etc.)
• A new application layer: API management.
• Hands on API management demonstration with Kong .

After all the machine\deep learning buzz, lets see what the future holds for the next phase of AI. An opinionated talk by an experienced architect and developer talking about how he sees the next generation of machine learning algorithms. What it could do, and how the syntax would look like in a programming language that was built for that purpose only.

Dependency injection is a software design pattern that implements inversion of control and allows a program design to follow the dependency inversion principle. Join me in this session to see how we can leverage Dependency Injection(DI) to make our design modular, clean and fast.

Cloud computing provides amazing capabilities for the modern application, but there are many pitfalls to be aware of – scalability, resilience, elasticity, security and more. In this session we will look at basic must-know patterns when architecting for the Azure cloud: Message-Oriented, Poison Messages, CDN, Priority Queues, Retry Patterns and more.

Do you know what developers do most of their day (except for surfing the internet)? Writing code? WRONG! They are debugging. The debugger is a powerful tool, but in this talk you'll learn tricks that will help find bugs in half the time and with less frustration. Because a happy developer is a productive developer. I'll show you to use tools that will point to you to right direction and features didn't know that are even there, for both development time debugging and post-mortem production analysis.

There's nothing new about the actor model, in fact it was invented in the early seventies so how come its now the hottest buzzword? in this session you will learn what is the Actor Model and why it helps making your system Reactive - scalable, responsive and resilient. You will get to know Akka.Net library that makes the Actor model a piece of cake.

Modern applications must handle a constant barrage of events and data sources—from a single sensor to a network of nodes and users pumping data into your system. Your system needs to respond in a timely manner. It should be resilient and recover when something bad happens, and it should know how to work with increasing usage. In other words, your system needs to be reactive. In this session, you’ll learn about some of the tools and practices that can help you achieve reactive architectures. You’ll get to know the Reactive Manifesto, and you’ll be introduced to the Actor Model, Reactive Streams, and, of course, the powerful Reactive Extensions (Rx) library.

Reactive applications are designed to handle asynchronous events in a way that maximizes responsiveness, resiliency, and elasticity. Reactive Extensions (Rx) is a library that abstracts away the sources of events and provides tools to handle them in a reactive way. With Rx, filtering events, composing event sources, transforming events, and dealing with errors all become much simpler than with traditional tools and paradigms. Reactive Extensions requires a change of mindset: you’ll learn to think about your application as a message hub that knows how to react to messages. After this session, you’ll better understand what Rx is, and you’ll have a starting point from which to effectively use it in your application.

In this talk we will present a novel approach for performing large scale computations (millions of events per minute). This approach is simple enough to be applicable to most existing cloud based solutions, and with minor alterations can be adapted to any business logic (this is the same approach we present in the soon to be published book “Earth-Scale System design”). This new approach is based on moving on from traditional Big-Data models to the closely related Fast-Data computation scheme using only three common “Tropes” (or computational patterns). In the talk the audience will learn how to identify and evaluate the optimization possibilities for their system, understand what measures should they take to improve performance, and estimate the impact of this change. We will present the open source tools we use, explore the options we have, trade-offs we are facing, the choices we made in the past and what we learned in the process so far.

Today there are many open-source infrastructures of Data Streaming. When I want to implement in my organization a real-time analytics application, Which infrastructure shall I prefer? Storm, Spark, Flink, Samza or what? But wait a minute, what does it cost to have a data streaming and how much resources I will need to put in it? And what will I gain from it? And most important - Do I really need it??? In this lecture we will try to answer those questions and more.

WalkMe is a javascript module that integrates into web applications. Our module's performance (CPU and memory usage) is very important to us as it affects the hosting application. Measuring client side performance is not easy as there is usually a lot of noise that gets into the measurement. In WalkMe, we have built a system that can accurately measure our important performance metrics and visualize it in graphs. The system includes a JS profiler, Selenium based automation, an ELK service that stores the measurements and dashboards that visualizes the measuring in graphs.

I'll share tips & tricks from my experience giving workshops on various tech subjects to geeks around the world.

There will be lame jokes, shallow quotes and at least one meme. No animals will be harmed during the making of this talk (unless you don't pick me, they a puppy might suffer :)

At AppsFlyer we provide a real-time analytics dashboard for Marketers. With our dashboard they invest $$$ budgets wisely. We aggregate some 8 billion daily events in real-time and our solution could not handle this load - dashboard just loaded forever and the Kafka lags were our daily and nightly headache. Product constantly demanded new features and guess what - we just couldn't do it! Moreover, we faced dangerous failures and the risk of losing serious data - something we obviously couldn't afford to do.

We started looking for a new infrastructure: We tried different databases and technologies and none of them provided the desired solution. We tried Cassandra, Mongo, Redis and Druid - with no success.

Join me on our journey and I will show you the current solution that implements real-time aggregation over MemSQL integrated with the batch processing over Apache Spark. The new architecture solved not only our pains but allowed us to aggregate X10 amount of data with much faster response times, keep up with product demands and it was a cheaper solution from the production cost perspective.

This talk is a story about the national Skillz CS competition that involved around 2200 students in the ages of 16-18. In the competition, we invented a game and the students needed to write a program that plays the game.

We will talk about how the competition worked, what were the mechanics that drove the students to be so excited and about the technical challenges we had to face

30 years ago, people were programming in Assembly - tracking down individual memory cells and registers. We’ve come along way since those early days: We’ve moved on to high level languages, magical runtimes manage memory. Fancy IDEs, static analysis and snippets have given us “ctrl+space programming” and boosted productivity further. As we push our programming ecosystems to higher and higher levels, we obsolete certain skills and open the world of programming to a new audience.

However, the higher level of programming and abstraction is not without a price. These, and other advancement in software engineering have changed our profession in numerous ways. We think differently, we model differently - and we have a very different skillset than our predecessors. As software engineering and the systems we build continue to evolve, so will our profession and skills. What skills should we emphasise today? And more important, what mindset and skills will we need in the future?

#DevOps, #NoOps, #serverless - every few years yet another movement to get rid of those pesky Ops engineers no one likes pops up. But like cockroaches, we can’t seem to be able to get rid of the buggers. Can it be we just don’t really understand what “operations” is all about?

When people hear “Operations”, they think of managing servers, of automation, CI and deployment pipelines. But Operations is not about any of that - operations is about making the machines you built/purchased/programmed earn money (or whatever the goal of the organization is). Making your business work is what operations is about.

This talk introduces the principles and history of Operations Engineering, the challenges and responsibilities of practitioners and the transformations IT Ops world is experiencing in recent years.

I will explain taking care of a newborn baby in terms of production engineering. Including but not limited to: alerts, analytics, escalation and other production engineering issues.

Efficiency is what makes or breaks a large scale operation. At AppsFlyer, we process some 8 billion events per day (in real time), leading to efficiency considerations to be treated as a first class citizen in every design and discussion.

At AppsFlyer, we measure our efficiency in dollars spent and machines used, but more importantly in terms of development and operation simplicity (or lack thereof), as well as the time developers waste on maintaining existing services instead of focusing on building new ones.

In this session, Adi Belan, who leads our Real-Time Attribution team will share our best practices for scaling efficiently, using a mixture of AWS and proprietary tools.

Bottom line: American’s lie almost as much as Trump. So getting valuable feedback from Americans on your products or services is a bit like digging for gold: you need to know exactly how to sift through the dirty lies to find valuable nuggets of truth. In this talk, I’ll walk you through the ins and outs on how to engage with and read Americans--or really any person--and find those valuable nuggets that’ll take you, your designs, and your product to the next level.

With the newly minted Sprint by the Google Ventures design team (Jake Knapp, John Zeratsky and Braden Kowitz), the industry is a buzz about a new framework that prophesizes an agile approach to design, measure, and test market problems all in 5 days. But is this design sprint the savior for which been waiting? We took the design sprint for a test drive--putting the theory into practice. I’ll walk you through the design sprint framework, what worked for us, what didn’t, and what we’d change or keep in mind for the next time--so that you, too, might be able to hold your own design sprint.

We all know that UX is a good idea, right? Since good UX sometimes requires extra investment, it is often neglected due to deadlines, lack of resources, misunderstood value, and the ever-elusive ROI. In this talk, I’ll present some market research, case studies, value points, and even quantifiable methods for measuring the value of UX that you can use in making the business case for good design and UX in your organization.

Mal ( Make-a-Lisp ) is a Clojure-like Lisp language invented by Joel Martin for educational purposes. It has interpreter implementations in 56 programming languages, including C, Java and Python, but also Make, PL/SQL, Vimscript and many others.

Building a Mal implementation is a great way to learn about Lisp in general and about the specific language you're implementing in. The talk will present the step-by-step process of building such an interpreter, incrementally adding features like variables, conditions, tail-call optimization and macros, finally reaching the last step which is capable of self-hosting (running the Mal interpreter which is written in Mal).

If i can get 10 minutes, it would be better.

Anyway, I will talk about my perspective of the future of docker Bullets:

• Why do you need docker?
• Conclusions from Amazon CTO
• Docker 1.9
• The Future

• Don't need Dedicated Server
• Container as a Services (CaaS)

• What you need to do

For JavaScript, implementing certain coding best-practices can also be the most effective optimization you can apply to your app. At the same time, other best-practices can significantly reduce your app's performance. In this session I will explain how some best-practices enable the JavaScript Engine optimizer to generate much more efficient native code from JavaScript. Conversely, I will also show that other common best-practices result in code that is much less efficient. Properly applying these lessons will facilitate code that is simultaneously more maintainable and more efficient.

One of the biggest challenges in running mission critical data processing jobs is making sure new code doesn't break when it meets production payloads.

In this talk we'll go over highlevel concepts we use at Totango to test new Spark processing code on production... So that we can deploy new code with velocity and confidence.

Druid is an open source columnar analytical data store that is competitive with expensive closed source solutions in terms of performance and scalability. However, Druid is unique because it is optimized for immutable time series data and uses it's own highly flexible query language. In this session we will learn what makes Druid so great for certain OLAP workloads by reviewing it's ecosystem and delving into it's unique architecture. We'll also go over production deployment scenarios, and learn how to use it effectively for real-time analytics.

We've gathered a lot of expertise with Druid at Appsflyer, and we'd like to share our knowledge with you. The second part of the session will be dedicated to questions and open discussion. Let's talk about your use cases, and see how Druid fits (or doesn't fit) into your pipeline.

Writing UI automation that isn't flaky is hard, but there is a set of golden rules to ease the pain.

In this talk I will share my experience with creating a robust UI automation framework on top of Selenium that has a proven track record of running hundreds of tests on each push with unprecedented stability.

Cucumber claims to offer "Simple, human collaboration" , with the added bonus of plugging test automation to the highly structured output of that collaboration.

Sounds great, but while the idea behind Cucumber is indeed "human-friendly", its real-world implementations are anything but. It's impossible to keep the user-stories standardized or organized, and usually the whole thing just spirals out of control until it's shelved (or is left as automation specs for the developers - with no collaboration whatsoever).

While implementing Cucumber at Infolinks , we tackled and overcame these issues by building a Cucumber wrapper in the form of an all-in-one dedicated IDE. It provided on-the-spot guidance and business-logic validation for writing user-stories, as well as access to the company's test-storage and other systems. This implementation actually made Cucumber usable to humans, and realized its vision for "Simple, human collaboration" .

I'm in the process of transforming the IDE into an open-source extendible project.

There is heated debate on whether coding in interviews is good or bad, and different ways on how to conduct these interviews.

My views in the matter have changed over the years and I want to share what I found out that works for me.

• When time is more than money
• Selecting the right lifecycle & instance type
• Reservation strategy
• Spots usage
• Balance HA with traffic costs
• Tools to detect low utilization
• Database efficiency implications on costs
• S3 costs optimizations
• Instance storage costs/performance considerations

• (NOT) Loosing traffic while deploying
• Fixing build performance
• Volume issues at bootstrapping
• The exile JVM
• Free developers from your burden with self serve
• Docker registry reconstruction and scale
• Deploy from branch
• Detecting versions inconsistency
• Cleaning old images without breaking things
• Tracking it all with event-stream, slack and graphite

This is a the story on a 16 years old startup who had to re-invent itself.

We often hear lots of success stories on new startups that were able to break their way to hyper growth through disruption. What we don't hear often is what happens to startups that get disrupted themselves. In this session i will share my own personal experience as the CTO and founder of GigaSpaces on how we distributed the traditional database market with distributed in-memory database and how we got disrupted ourselves later by other open-source NoSQL startups. What we have done to disrupt ourselves by launching new open-source products in cloud orchestration and big data world and how those moves transformed our business and company DNA.

Many of the lessons from this experience can serve other entrepreneurs that are facing disruption and need to deal with impatient customers, investors and market.

During the past 5 years, I’ve been in charge of leading the CI efforts for the development of the RHEV product and an active infrastructure maintainer for the oVirt.org opensource project. The introduction of CI as a new concept was a real revolution at that point of time. Over time, as the product evolved and matured, we grew with it. The technologies we used and the approach we took to test it, changed completely based on our experience, lessons we’ve learned and new technologies that emerged over time. In this session I will share with you the tools, technologies and lessons learned on how to test an open-source based virtualization product. Together we’ll review the complexities we encountered, and as a result our insights and why we’ve shifted from one paradigm to another and found a new revolution.

Here's my article published in InfoQ that this session is based of: https://www.infoq.com/articles/in-app-subscriptions-made-easy

The session will be about the challenge of providing Android & iOS In-App subscriptions, in a large-scale B2C web-based environment:

• The change of mindset towards the mobile world
• The basic architecture
• Providing RESTful payment API
• Monitoring subscription changes

ES6 is a huge step forward for JavaScript, adding many new features and capabilities to the language. But when you compare ES6 to ES5 - the previous version of JavaScript - it's apparent that most of these new features are essentially syntactic sugar. This is what makes it possible to construct transpilers, such as Babel, that transform ES6 code into the equivalent ES5 instructions. There are, however, several new capabilities in ES6 that cannot be implemented in ES5. In this session I'll point out these capabilities, and explain what they can do and why they were added to JavaScript.

One ingredient that makes a great developer is, of course, being able to solve problems using great code. This is the truth that brings you to conferences to hear lectures about programming languages, techniques and approaches.

But it's not the only ingredient, and the industry is in the process of accepting that it isn't the most important ingredient, either.

If the only thing you're doing for your career is learning more about programming, you're missing something very crucial.

This talk will clue you in on what you're really missing.

“I like work: it fascinates me. I can sit and look at it for hours.”

― Jerome K. Jerome

We chose to become software developers because computers are fun, and getting them to do complex things is incredibly challenging and gratifying.

Yet many of us who get to work in software will eventually, or even immediately, find ourselves in "the grind" - droning away every day from weekend to weekend, coffee break to lunch break.

Something is not as it should be.

What is it that isn't right when we know we should love what we do, yet find it difficult to wake up every day and march to the office? What's the difference between someone who works with enthusiasm and motivation, and someone who dies a little every day in front of their monitor? How can we be productive, happy, and derive satisfaction from the work we do?

This talk introduces a few powerful insights that touch at the core of what stands in our way to self fulfillment, and provides practical ideas to start taking steps towards a better way of operating.

Containers are "making us rethink how we deliver software." But they have their limits. Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications. During this session, I'll explain what K8s is in just 5 minutes so you too join the containerization revolution!

Unbounded, unordered, global-scale datasets are increasingly common in day-to-day business (e.g. Web logs, mobile usage statistics, and sensor networks). At the same time, consumers of these datasets have evolved sophisticated requirements, such as event-time ordering and windowing by features of the data themselves. On top of that — consumers want answers now. The inventors of Apache Beam - Google, has evolved our earlier work on batch and streaming systems (including MapReduce, FlumeJava, and Millwheel) into Apache Beam, a new programming model that allows users to clearly trade off correctness, latency, and cost.

Concurrency in modern computers has changed. Moore’s Law, which observed that “the number of transistors in a dense integrated circuit will double approximately every two years”, is no longer true.

Nowadays, to handle concurrency, modern computers contains more cores that bring more computation power. To maximize such hardware architecture, concurrency programming kicked in. Most of the concurrency models under the hood use locks, so the code becomes serialized in some parts. This brings less throughput & more latency.

HTM (Hardware Transactional Memory) is a new extension to the modern CPU, which helps speeding up multi-threaded software. Databases, Queue & Cache systems, Interpreted languages and more core software elements already support it to gain more speedup.

The most popular language in the world - Java - added (in version 8u40) support for that mechanism by default when the CPU supports it.

So, if I already have it in my core software, and Java has support for it under the hood, why I should care about such “mechanical” stuff?

Well - like any black magic in software, you should be familiar with how it works in order to get the most out of it. And besides - it’s fun!

There are many criteria to consider when building your microservices architecture for scale and performance. The two major ones are programming language and inter-service communication.These decisions dramatically influence the scalability of the system.

For our inter-service communication we chose NATS.io - an open-source, cloud-native messaging system for distributed systems; and Golang as the programming language.

NATS.io is a highly performant Publish/Subscribe system which has a simple model that leverages both synchronous and asynchronous communication.

Golang has a simple yet strong concurrency model, which helps building highly scalable systems fast without compromising simplicity.

Come to hear how we build it @Juno - a new fresh approach to ride sharing.

Building a decent app is easy this days, there are plenty of tutorials, videos and blog post about it. In this session I'll try to go over some of the top mistakes that everyone of us is doing while building his app. This will cover all the aspects of building bad app- technical, UI & UX, and marketing. So each one of you will be able to adapt his own favorite bad pattern and ruin his app.

microRNAs are bio-markers, which may indicate cancer and other diseases even at early stages. We partnered with a startup to develop a pipeline and NLP classifiers to analyze medical research documents to find relations between genes and microRNAs, and diseases. The generalized code and leanings are open sourced.

Functional Programming paradigms are great in many aspects, but can they lend themselves to the actual design of the service? If so, can they also lend themselves to the entire system architecture?

This talk will show how we, at AppsFlyer, utilize ideas such as immutability, function composition, CSP, CQRS, referential transparency etc., in order to design our system - from the inner-service level, through our service-to-service pipeline and even to our deployment infrastructure.

A lot of apps use notifications! Most use it in an almost benign capacity while some.... some are absolutely annoying! But a chosen few have mastered what it means to be a good Android citizen and are using notification as a tool to serve and delight their users. This session is about how to be one of those apps (first step at least) and it relies on real case studies and user research.

Things I wished we knew before our app got "Big in China". China is a huge potential market for many consumer apps and services. However, the internet infrastructure and regulation there presents some new challenges for the developers who want to establish a market there. We will try to show our (ongoing) path in Joytunes for serving content to our Chinese users, as well as the current state of the Internet in China - infrastructure, regulations, and potential solutions.

We know how to scale technologies that's what we’re good at, recruiting on the contrary is harder, it's manual, tedious and resource intensive. Just imagine how much time and effort is consumed by trying to get the right candidate, Moreover, working with the right kind of people tends to be a crucial aspect for retention of the existing team. In this session I’ll cover methodologies, hacks and tips to build your dream engineering team at scale without losing the balance of letting the right people in.

The role of the developer is changing.

The days of "I just code features. QA are responsible for testing and quality. DevOps are responsible for continuous integration. Someone else is responsible for deployment." are over.

Software developers today are working in fast-paced projects with frequent code changes and deployments. These projects are destined to fail unless developers become accountable for their changes and take ownership of the entire software development process.

Developers must own

• coding (naturally)
• Quality through Automation of multiple test layers (from unit up to applicative tests) to provide a level of confidence in code changes
• Continuous integration to test changes in larger contexts
• Continuous deployment to get your changes out there fast and increase customer satisfaction
• And monitoring to keep that customer satisfaction high.

In this talk I will present a case study of building a new product by Perfecto. I will show what it means for developers to take ownership of the process, including the required capabilities and tools needed for the different tasks, and provide insight, best practices and samples from our project.

In the last 6 months or so, Perfecto is in a transition from a monolithic single-tenant servers based service, to a multi-tenant microservices based service.

During this period, we have learned how to develop, build, test, deploy and monitor highly available and scalable Docker-based microservices in AWS, leveraging multiple AWS services such as ECS, ELB, Route53, CloudFormation and more.

While there are still (like always) things to improve, we have learned quite a lot along the way about what is required from a good CaaS (Containers as a Service). We also found some issues with AWS infrastructure, some we worked our way around and some we’re glad we are at least aware of.

This session should be interesting to anyone who is planning to or in the process of using Docker all the way to production, be it using AWS or any other CaaS infrastructure.

ChatOps is great. It's awesome. When trying to adopt it in enterprises, many complexities arise - security, uniformity, UX and accessibility over legacy platforms. How do you bridge the gap? How do you transform ChatOps from a cool factor into a mission-critical control point even in the enterprise? This session addresses the road we've done (and still doing) in HPE Software to transform ChatOps into the leading solution our customers can adopt, while contributing it back in the open-source fashion and paradigm to let everyone enjoy and expand their ChatOps experience.

Hey there, dear software developer. How are you doing? Oh, you've just finished to conceptualize your new feature? That's awesome. Just a quick question - did you by any chance thought a little bit about security? Oi, no? Well, don't worry - help is here to quickly boost the security level of your design!

Everyday new features and code lines are created after long, hard discussions about concepts and properties, however in a lot of the cases security is just shoved out of the way since it is overloading, tiresome task that most developers don't want or just don't know how to take on. Unfortunately, design flaws are something that is very costly and when it comes to security, it also creates bad reputation to products or services.

This lecture would build you up from the ground, and will take you from the very basic concepts of secure design into the deep world of using known tools and frameworks with a strong emphasis on Microsoft's Threat Modeling Tool 2016. This tool helps to visualize, prioritize and mark the risks that are hidden in your software due to improper design of security. We will explain how do we define threats, what are the categories of software secure design and see how by just drawing the data flows of our feature, we can get full and automated analysis of the system's security design.

Read a post I wrote about it here: http://www.amiturgman.com/blog-1/2016/5/18/controlling-your-backend-platform-using-an-extensible-web-based-command-line-interface

Web-CLI is a web based command line interface control that can be used for managing and administrating your app. The console is designed to be extensible, allowing new commands to be easily added and integrated into it using the plugin design. The console supports most of the common CLI features such as basic commands, environment variables and commands history, as well as more advanced features like context-based instances of the console (AKA tabs), a JSON-view control for viewing JSON results, HTML results, client side commands and styling, side-panel for sticking commands’ results, and more!

Scaling your architecture while you build your startup - one phase at a time. How we slowly scaled Gett, what lesson were learned and how we scaled Bringg faster and more effectively.

I will touch on technologies used, alternatives considered, failed architectures tried, how you test for scale and how you measure success & failure.

The Museum of the Jewish People (aka Beit-Hatfutsot) has been collecting content since 1978. In that time we've gathered articles about 6,650 places, 8,182 personalities and 17,323 last names. We also have 72,049 photos and about 4.8MM people in ~11K family trees.

Until May 2016, to access this wealth of information you had to either come to the Museum and use our client-server system or send a request by email together with a payment of 25 NIS. Today, it's all online under the CC-BY-SA-NC license and the code is open on github.

In this presentation I'll present what it took to convince the organization to release the data under CC and Open Source the code, focusing on tips & tricks that can help free other yacks.

Bash scripting and command line utils can be used as powerful tools for many big-data tasks. In some cases command line utils can run faster and more efficiently than running a MapReduce job. In this talk I will cover the scenarios in which one should consider using command line instead of Hadoop and cover available tools and recommended usage.

.NET developers today enjoy a bountiful source of platforms, tools at their disposal. With Xamarin they can target all the major mobile platforms and Azure providing cross cutting features for mobile developers and the necessary scale to support any degree of mobile clients. In this session we will take Xamarin Forms, Azure App Services and SignalR to create a full blown Messenger app in just 40 minutes.

What is Echoes Player

Echoes is a great youtube player. It's fun & easy to listen or watch videos from youtube with Echoes. What if youtube was designed to be used as music player? I started this project on 2012 to experiment with front end frameworks, among the first was Backbone.js. Later on I migrated it to React , angular 1 and nowadays angular2 .

What is Good for?

Through the experience of developing this personal tool, I discovered that it is easier to experiment and get a somewhat solid facts on how it feels to use framework "X". Moreover, there's a chance to take out common functionalities into other open source projects. i.e., angular2-infinite-scroll - which in some ways - agnostic to angular2, and have become a full community open source projects - recieving pr's and issues from back from the community.

Why not Todomvc.com

Echoes is more robust than todomvc, supplying a good playground to experiment with few perspectives in frond end engineering. However, it is lighter than a large scale application and aims to be as modular as it can be.

What Are This Session's Benefits

Through out the session, i'll point out the importance and benefits one can expect from getting into an open source project, leading an open source project and benefits of self growth from this experience.

The Open Source Projects Of This Experience

• http://github.com/orizens/echoes
• http://github.com/orizens/echoes-ng2
• https://github.com/orizens/echoes-mobile
• https://github.com/orizens/angular2-infinite-scroll
• https://github.com/orizens/angular-es2015-styleguide
• https://github.com/orizens/TypeScript-TmLanguage

In a world that is evolving towards microservices architecture, exposing REST APIs and inter-process communication is very common practice; however, as this practice is widely adopted the more complex it becomes.

In Stratoscale, the company revolutionizing the data center, The development team moved to microservice architecture, and was looking for a way to simplify the development of inter-service communication. This solution should allow Python developers to concentrate on writing the service business logic and not be troubled by the REST framework.

This is where Hammock comes into play.

Hammock (https://github.com/Stratoscale/hammock) helps you expose a service API and easily consume it in another service. The development teams don’t even need to understand what REST is!

Besides simplifying writing of service APIs, this framework also provides auto-generation of a client (python-bindings) and auto-generation of the server APIs. In addition, there is built-in support for the Oslo policy configuration. The Hammock library is based on the Falcon open source framework, and was designed to support multiple backends.

In this presentation, the audience will be introduced to the revolutionary Hammock concept and will learn why, when and how to use it. The presentation introduces real code samples and shows a live demo.

In a world that is evolving towards microservices architecture, exposing REST APIs and inter-process communication is very common practice; however, as this practice is widely adopted the more complex it becomes.

In Stratoscale, the company revolutionizing the data center, The development team moved to microservice architecture, and was looking for a way to simplify the development of inter-service communication. This solution should allow Python developers to concentrate on writing the service business logic and not be troubled by the REST framework.

This is where Hammock comes into play.

Hammock (https://github.com/Stratoscale/hammock) helps you expose a service API and easily consume it in another service. The development teams don’t even need to understand what REST is!

Besides simplifying writing of service APIs, this framework also provides auto-generation of a client (python-bindings) and auto-generation of the server APIs. In addition, there is built-in support for the Oslo policy configuration. The Hammock library is based on the Falcon open source framework, and was designed to support multiple backends.

We will discuss how to write code that Fortune 100 companies will want, buy, and use. How one line of code changed our business strategy. We will also review the challenges in designing applications to customers in more than 65 countries, and will share stories on why enterprise software is sexier than you think.

"Clean Code" by Bob Martin is probably one of the most important practical documents out there; A must read for all developers, if you will. In this talk I will discuss the importance of language and culture in applying the discussed principals, and show why in my opinion Groovy and its rich ecosystem is best for it.

When your program fails, you have a stacktrace, when your call to webservice it returns text in HTTP error.
But what do you do when everything is working fine, just slowly ?

Java has excellent profiling tools, but on-cpu profiling is not enough. Slowness can be caused from other processes competing with your server on the CPU, from saturated IO devices.
And how can you do all that to a live production server, without interfering with ongoing customers' requests?

We will show how to quickly recognise various bottlenecks of a live java server, running on Linux.
We will survey the USE methodology for analysing performance problems, with common Linux and Java tools for various performance analysis.

A short talk on why ZFS would set your hair on fire, sure you write your fancy code using the latest tech but your still running on legacy FS (NFS, HFS, etc..), ZFS will bring your servers/desktop?! into the 21 century:

• Flexible server grade raid/mirroring in software.
• Fully Copy on write (snapshoting).
• Cutting and slicing your storage (datasets).
• Getting more space (dedup and compression).
• Block level synchronization.
• Production ready ~! (looking at you BTRFS).
• Self healing checksumming (prevent bit rot)
• Very portable Linux, FreeBSD, OSx.

Ninety percent of consumers use multiple devices to accomplish a single task, according to Google research. That’s a lot of people moving between smartphones, tablets and desktops – and they expect a seamless experience.

But the dynamic nature of the digital market makes this a challenge for dev and QA teams: New mobile devices and OS versions enter the market each quarter and desktop web browsers are regularly auto-updated. This puts organizations that have built mobile web or responsive web applications under more pressure to consolidate their testing tools and speed up releases while maintaining high digital quality.

With that said, it’s no longer practical for dev and QA teams to test desktop browsers and mobile devices separately, using different test frameworks. In this session, Perfecto’s Head of Product Owners Asaf Saar will show attendees how to execute one test code in parallel across mobile devices and desktop browsers within the same cloud-based “digital test lab.”

He’ll focus on these key areas of digital platform testing:

1. The key requirements for a digital test lab
2. Setting the right test coverage for your projects
3. Analyzing the test results

Asaf will also show in a demo how this kind of cross-platform digital testing in a cloud-based lab can easily fit into existing test automation tools.

Audience takeaways: Attendees will be better prepared for digital quality testing by learning: – How to build the right digital test lab – How to utilize existing test frameworks like Selenium and Selenium Grid to efficiently test across digital platforms – How to increase quality awareness within Agile teams through an actionable feedback loop based on digital test reports.

Meekan developed apps for iOS and Android, and an Outlook Add-in, and threw them all away to build a chatbot. It was apparently a good move: The scheduling assistant is used in over 10,000 companies worldwide.

What happened in the world of chatbots in the last year? What made them so popular? Is it just hype, or is there more to it?

We'll go over the benefits of bots over apps, how to make them more appealing than a command-line tool, and how to adjust yourself to the new Conversational UI.

In this talk i will give an introduction to one of the biggest open source projects out there today that transform and change the cloud and IT paradigms in data centres both in private and public clouds. We will talk about the OpenStack process, how all of these companies collaborate together and interesting projects and topics in OpenStack regarding containers frameworks, disaster recovery, networking and hybrid clouds.

August Penguin is the annual gathering of the Israeli Free and Open Source Software community. It has been occurring for most of the past 15 years, and is organized by volunteers in the Hamakor NGO. After several years in attendance and after taking part in similar conferences abroad, this year I decided to take an active part in organizing the event.

This talk will go over the story of how we organized the event, what mistakes we made and what lessons we learned. As an open-source, volunteer driven event, we had to handle different issues then those faced by commercial event organizers.

Holding events is an important part of maintaining an active open-source community, and I hope to be able to help other organize successful events for their respective communities.

The talk will be relevant for people who organize events and wish to learn from our mistakes, as well as people who are part of open source communities, where coordinating with multiple volunteers is crucial.

With bringg we've managed to demo, pilot, and win accounts of multiple s&p 100 companies, while developing a product and a company, with an r&d team of 6 people. How do we stay agile, how do we manage the day to day, the good and bad and the lesson we learned along the way. I'll also talk about the concept of an elite team, when it's right (and wrong) to build it, how it works in bigger companies like IBM (and it does!), and when it's the right time to sunset the elite team concept.

Physical devices connecting to the Internet and enhancing our life were supposed to be the next best thing, but turned out to be useless gadgets ranging from things nobody needs to glorified security fails. In this talk we will explore the entire technology stack, from UI through networking all the way down to the bare PCB, and learn how to connect things to the Internet in a secure, maintainable and sustainable way using nothing but open source technology and off-the-shelf devices. Some buzzwords will be harmed during the course of this talk.

One of the main reasons developers and managers leave companies is lack of transparency. While most companies are all for transparency, very few manage to practice it. On this talk I'll cover different methods which all teams can easily adopt. Using dashboards, working better with Slack, internal podcast and even using democracy for some decisions. The talk will also focus on how to communicate business/ sales updates and how to handle 'bad' times.

Serverless Architecture is considered to be the next phase in the evolution of cloud development. Its building blocks are functions and not projects, a bunch of stateless “nano-services”, that can scale automatically and charged only when used. It enables teams to stop worrying about operations and start focusing on development.

In this talk I'll cover the Serverless Architecture practices, review and demonstrate the serverless ecosystem (for example, the Serverless Framework ), its use cases, and how it can make development faster and cheaper.

Using Webpack, ES6(Babel), AngularJS, and several other great tools to create the best platform for AOL's video Marketplace. The platform is used by a vast number of companies, and is modular according to each company's needs. We need lazy load per each module, a unified design, spread across a dozen teams spread around the world(Ukraine, London, Dublin, USA, Israel and etc.), all converged into one big application that loads quickly and has 100% uptime and reliability. This lecture will show what we did to achieve this goal, and how it helps us in every perspective.

Redis 4.0 will introduce Modules - a way to extend Redis with new commands and data structures with native speed of execution. This will change Redis forever, and might create a shift in the whole NoSQL ecosystem.

In this talk I'll review the modules concepts and how they came to be, and demonstrate the very simple and elegant API, in a step by step guide to writing a redis module.

Setting an "average" price for a mobile app and demonstrating the break-down of what it will cost you. Then understanding what product will you get at the MVP launch why is it different from your dream product and what should be your next steps.

The concept of Antifragility was introduced by Nassim Taleb to describe systems that benefit from impacts and volatility.

In this talk we will discuss how this concept may be applied in the field of Software Design with the goal of developing Change-Resilient Systems.

In particular we will address two patterns which frequently appear in Antifragile systems:

1. The Barbell Strategy and the importance of the separation between high-level abstract elements and concrete implementation details.

2. The Componentization Strategy and its applications in SOA, Microservices and Software Product Lines.

In today's fast and hyper-complex technological world, High Quality of deliverable Software products is becoming more and more critical. Autonomous cars, Cyber threats and Algo-Trading are an example of areas in which Quality could become critical and in some cases, fatal.

While the business is demanding more flexible and continuous ways to deliver Software products the need for new methods and best practices for keeping high quality Software development is stronger than ever.

In this session we will go over the necessary steps needed in order to cultivate High Quality throughout the Software Development Life Cycle and explain concepts like NO QA, Shift Left and Agile Testing.

The session will include real world examples.

Lessons learned as a leading engineer involved in the sales process of a very technical , heavily integrated, enterprise product to Fortune 500 companies while being a startup. Some of the topics we will cover:

• Preparation
• Building Rapport
• Surviving the info-sec review
• Overcoming tech obstacles

Including tips and real life example

If your service serves end-users there is a fair chance you'll want to moderate their inputs. It's gets quite challenging when you have to taylor solutions for many types of customers, each requesting for ad-hoc features while enforcing different policies.

In this talk we'll talk how to build a moderation system from scratch that will help you address many flavors of customers while enjoying a shorter time-to-market of features. Moreover, the same shown ideas can be applied into other domains requiring some kind of a rules-engine.

The talk will include snippets of Ruby code, but the demonstrated concepts could be applied to virtually any programming language. (no Ruby knowledge is assumed).

The world of Big Data is growing very fast, and with it the culture of BigData organizations is changing. The roles and relationship of analysts and engineers in big data departments is shifting to take on a differnt form.

I am a big-data section head in a large data company, and we recently made a big transition and a revolution in the way we work. I will talk about a transition from an assembley-line ETL writes, to autonomic analysts and Big Data engineers who provide their own product. We are still in the prosses of completing our transformation, and I will talk about the challenges we faced and are still facing today.

Shells are Domain Specific Languages. The domain has changed greatly since the shells we use today were conceived. The shells never caught up.

What I see is a void. There is no good language for system tasks and no good shell. What's near this void is classical shells on one hand and general-purpose (non-DSL) programming languages on the other. Both are being (ab)used for system tasks.

So I'm working on the solution. The project is at https://github.com/ilyash/ngs/

Developers often associate Redis with terms like caching/optimisations and not as a primary data-store.

We in Spot.IM use Redis differently than any other company, by using it exclusively for all aspects of our data storage.

In this talk we'll discuss how we take Redis to its extreme by examining real-world production solutions for various scenarios through building abstractions on top of Redis, while leveraging its unique properties.

The talk will include snippets of Ruby code, but the demonstrated concepts could be applied to virtually any programming language. (no Ruby knowledge is assumed).

In this talk I'll explain about Google's DeepMind, deep reinforcement learning technique which is a Q learning variant. I'll explain in details how it works and how to apply it to train a controller (bot) for a complex game such as Doom. With this technique the doom controller policy is learned from high-dimensional sensory input (Game Screen Image\Raw Pixels).

Sharpen your mind and instincts, and try not to blink , then follow me as I try to take you to your speed limit of coding.

In this talk I will:

• Introduce tools & techniques that will allow you to become more productive in your development environment.
• Speak about how I plan my coding in a way that will allow me to build robust software blazingly fast.
• As a bonus , I'll show you how to use gmail using only keyboard shortcuts - no mouse at all, and cut down emailing time in half

Adding JMX metrics end-to-end to our micro-services, while we were working hard on scaling out Logz.io made us have bare minimum patience for existing solutions. We discovered we had to roll our own JMX to Graphite poller - named “jmx2graphite”, Docker-based, so your can bootstrap it in 3 minutes. This lecture will tell the story behind developing it, the motivation, review existing tools and frameworks, and show a quick demo of it. Along the way we’ll teach you the toolchain we use to define our JMX metrics, expose and visualise them.

GitHub Repo: https://github.com/logzio/jmx2graphite

Note: This can also be shortened to fit "Open Source In Israel" track

Table of Contents for the lecture can be found here

I found a great open source project, but it was abandoned, I wanted to see if there is an active fork out there, but github just told me the network is too big. I created a little tool to see the best forks.

site

github

I am running it on hyperdev.

גלשתי לעמוד פרוייקט קוד פתוח

אך הוא בדד התנפנף ברוח

את רשת ההתפצלויות שלו חיפשתי

אבל תוצאה שלילית קיבלתי

יותר מדי מזלגות לזה הפרוייקט

אז בניתי עמוד כדי לראות את זו הרשת

On December 2015, during an internal Wix Hackathon, we decided to rewrite our aging Micro-services infrastructure. This is our story. In this story, we will see how to build a modern infrastructure that enables you to deploy a self-servicing grid of computers on which micro-services can run and discover one another.

Will I show the best way to build a Micro-services infrastructure? No, but I will be showing how easy it is to build using off the shelf components like Mesos, Node, and Nginx. Through describing the process of building one for a Hackathon, you will understand, in a more visceral way, what consists a Micro-services infrastructure, and what you will need to think about when you will build one.

How would development of software look like if developers stop relying on QA and write the tests themselves? Would it be beneficial to the company? Essential? In the talk, Gil Tayar explains the reasoning behind the methodology that guides Wix developers.

Developer Testing is the ability of the developer to ensure, via automated testing that the developer writes, that the software is (mostly) without bugs. Most developers grumble that their superiors don't allocate time to write automated tests because "their is no time". This lecture explains to the manager why it is essential to the company that developers write their own tests.

Gil is a software architect at Wix, and his lecture is meant for everybody - managers and developers. Most developers do not develop tests in parallel to writing their code, and this lecture will gently remind them why they need to change their methodology, and stop relying on QA as the gatekeepers of quality in the company.

In a light way, and with humor, Gil explains how a company with and without Developer testing looks like, and explains the methodology that proves itself at Wix.

Why do we get paid to write information management systems? Is it because our clients are suckers for trendy infrastructures, databases, and sexy user interfaces? Of course not. It is all about the money.

The new system should make the client’s business more profitable. How? By making the business procedures more efficient. This is done my modeling the client’s business domain in code. In professional lingo we call it Business Logic, and it is the crucial part of every system. Despite its importance, this aspect of software engineering never got the spotlight it deserves.

It’s the time to fix this.

By the end of my session you will have a strong grasp of the four business domain modeling patterns: Transaction Script, Active Record, Domain Model, and Event Sourced Domain Model. You’ll have a simple, yet strong heuristic for choosing a modeling pattern which fits best your business domain. Also, I’ll present the ramifications these patterns have on overall system’s architecture, and automated testing strategy.

Full Title: "How ironSource.atom streams 200B+ monthly events into Redshift in near realtime with Node.js and Docker"

-> How we handle billions of daily events. -> The lessons we learned about streaming data into a data warehouse. -> Docker and Node.js deployment at scale.

So you’ve created an open source project and you’ve started to build a community around it. Congratulations! So how is that going? Is the project succeeding? Can you see improvements from week to week? Are you getting closer to your goal? Do you have a goal?

Many open source projects start off with a great idea, but often they lose their way due to a lack of measurable goals. Open Source projects are different in that the ultimate goal is not usually focused on increasing financial revenue. If that’s the case, we need unique measures of open source success.

As a community manager of a relatively young open source project (http://cloudslang.io) I want to share some of our experiences and methodologies we use for measuring the success of our project. I want to demonstrate how we have adopted the Pirate Metrics model to the world of open source to measure our progress at each significant level of user engagement.

I will provide detailed examples of the metrics and share some of the tools I use to collect and track these metrics.