Proposals

Working on big data can be a hard task, especially on extremely large scale data which requires massive resources and time. This might cause long development cycles and production issues. In many cases, applications can be accelerated dramatically if some approximation is allowed. The idea is to find a sample of the data, that enables fast processing on one hand, but achieves good result accuracy on the other hand. Some of these sampling techniques are used 'behind the scenes' in popular big data processing frameworks such as Hadoop MapReduce and Spark. In this talk, I will present sampling techniques that enable big data applications to run faster but still obtain accurate results.

Annotated maps of retail stores are a valuable data. In this talk we would share the story of how we created Store Mapper - an Augmented Reality and Deep Learning based mobile SDK which generates such maps. Utilizing Crowd Sourcing we show how Store Mapper is activated at scale.

It’s always fun to blame react native for everything that is wrong in our lives. However, what we keep finding, again and again, is that for most of the cases. Writing better performant react code can fix our performance issues. In the last couple of years our team built a huge production app in react native. In this talk I’ll go over some of our lessons learned in regards of react native performance and how to improve your app’s performance subsequently.

Many teams plan ahead by creating a roadmap for their product or a list of technical aspects that requires attention. The roadmap acts as a beacon for the team when making decisions and when evaluating the progress. The same approach can and should be taken when planning the future of the Team and its growth. In this talk, I'll share some past experiences and give tips and insights on the process we're using in order to set expectations and measure the team itself. This talk is valuable to any manager or team member striving to improve the way their team operates.

Every project starts from a single task. Our first task in Kaduregel Shefel, an alternative art project documenting cultural diversity through football, was to produce our first ever exhibition at an underground gallery in Tel Aviv. The exhibition was a success, with raving reviews from both visitors and media. This was an inspiration for us to continue and expand the project. As the developers that we are, we decided to be agile in order to scale. Using scrum, we were able to scale to video content, producing events abroad, managing communities and meet-ups, collaborating with artists and creating unique products. In this talk we will explain how we leveraged agile on underground art.

Most developers have been to the situation where they encountered a legacy and very threatening code, with a lot of unknown functionality, and they don't know from where to start. Usually this is not a very pleasant task. In my talk I would like to explain the methodologies of refactoring a legacy code and what is the best and efficient way to do it, without breaking the functionality of the system. I will explain from where to start, how to do it carefully, how to use existing tests and which tests it is important to write. Hopefully, after this session you will fell more comfortable and confident to take those tasks !

Research has shown that our minds go into autopilot when we follow routine. But sometimes these habits have negative outcomes. That's how we end up taking the elevator instead of the stairs, driving too fast, or littering instead of looking for a nearby waste basket. In this talk we'll look at creative approaches from around the world that use fun to change routines, resulting in positive outcomes and better habits. We'll also discuss how you can apply these ideas to built better habits for your team and your users.

Most developers (and also some product managers) don't have a lot of experience when it comes to meeting with clients. However, from time to time and in some scenarios, you'll be expected to attend one or even lead it (when you're heading your own venture). In this session I would like to focus on how to make the best of a client meeting: What to do before, during and after the meeting. After this session you'll have all the tools to become a client facing superstar.

Together, they let us standardize both our client-side and server-side around the entities we care about and create an entity-oriented data flow instead of focusing on data-specific APIs, regardless of the physical architecture we choose. In this talk, we'll learn what makes these two so good together and how we can make this romance grow and last to our benefit. We'll show how you can wrap your rest API with GraphQL, to get most of its benefits quickly and effortlessly. We'll also review the key factors and practical know-hows for successfully creating and maintaining this love affair, including authentication and authorization, error handling, caching and more.

We were struggling with a very challenging problem - and every path we took lead us to a dead end... A visit to the 2017 Reversim summit gave us a new direction we did not consider - Biomimicry. During this session, I will present the concept of Biomimicry algorithms - biological processes are inherently algorithms that nature has designed to solve computational problems. I will also demonstrate some of the concepts of treating job postings as a flock of birds. By the end of the session, you will have a new perspective on nature and potentially a new tool in your problem-solving kit.

Early in 2017, our existing data aggregations were just not cutting it. We tried shifting aggregation over to a Spark based framework and found it was lacking for our purposes. By employing the concept of tree-based aggregation we achieved better performance, better scale in reduced cost and also less developer's headache. Come to this talk to learn all about it, and see if your organization too can benefit from switching over some map-reduce functions to the forest.

As DevOps engineers we interact with many systems all day, every day. Cloud providers, docker registries, git repositories and a number of different API's that all need authentication and credentials. Where are all these credentials stored? Hopefully not is a public repository (yes that happens as well) but on your laptop or workstation. And when your workstation is compromised? All your credentials are now compromised as well!! In this session I will walk you through such a day to day workflow - of how we usually work - where the shortcomings are and which opensource tools we can all use to manage these credentials in a much more secure and much better way.

Native Reactive Streams with JDK 9 (and beyond) Starting from JDK 9, you can use (and enjoy) the architectural concept of Reactive Streams (RS) native-style. No need to use any 3rd party library (like RX Java and a'like..) The RS model offered by the JDK offers asynchronous publishing of events, giving the clients the ability to dictate the pace of the events consumption (a.k.a back-pressure), allows chaining of several "processors" as part of the RS pipeline and many more features. In the session I will demonstrate how it works and behaves, what are the strengths (and weaknesses...) of this feature and an example how it can be used in real system.

In an open source community, different people have many different ideas and concepts of how CI flow should look like. Especially with complex projects which are being built upon multiple languages and technologies and composed from many smaller projects such as Virtualization and Containers. Providing CI for such projects can be a challenge. Come and see how oVirt (the Open Virtualization Project) CI team overcome such challenges with our "Standard CI system". A must talk for anyone interested in how to bring up a CI/CD system today.

Will present key features of React 16.3 including: Fiber - Start with Virtual Dom, Reconciliation Algorithm, Stack Vs Fiver, continue with Fragments, Error Boundaries and Context API - Will be doing Live coding for part of the features. Finishing with a glance at the future of React.

In this talk we will review some common UX mistakes, you will probably be familiar with some of them, and a hidden smile will appear on your face, when it will be mentioned... After this talk, you will: * Have a short checklist of issues you need to look for prior implementation the UX * Know what to look for and how to avoid these UX mistakes * Have tools to convince your manager to shift the focus to the fun parts you always wanted to create

I intended to briefly introduce Cornichon. Show some cool teasers and examples, and compare it to some old common tools. I hope that this talk will encourage engineers to evaluate some new tools and to refresh their stack more often. It's also brings some fresh breeze when updating the current tools.

Starting from versatile reactive programming libraries, and growing up to huge data streaming platforms scaling to thousands of nodes, streaming is becoming an important idiom occupying multiple niches—from frontend to backend, from elegant approaches to dealing with I/O to large scale distributed data processing. The talk will put a spotlight on solutions from two ends of the spectrum: RxJS and Akka Streams as reactive programming libraries, and Apache Flink as a streaming data platform. We will discuss similarities, and also where those similarities end.

We all use cloud object storage extensively, like Amazon S3, Azure Blob Storage, Google Cloud Storage and others. However, not many utilize its unique capabilities and advanced features, such as versioning, security, life cycle... Throughout my work developing Ceph object storage and supporting large customers, I’ve seen a lot of incorrect and sub-optimal usage. This session will briefly discuss object storage design, highlight valuable features and review practical dos and don’ts.

Over the past year we’ve gone from having 1 POP in GCP to 6 in GCP and 1 in AWS . The journey took us through multiple AWS regions, a region in Azure, and one in Rackspace (all with live production traffic for prolonged periods) . We wish to share this journey and the things we’ve learned through it

We spend a LOT of time optimizing our pipelines, work environments etc. Why not use the same skills to make our home life better ? Inspired by the John Willis Post of the same name: https://devops.com/homeops-learning-devops-home/ But takes a slightly different approach This is a head fake lecture on how to get into an "optimize everything" mentality. If you say that out loud right away, people will just nod and carry on sitting in traffic instead of optimising around it. They will still go to the grocery store instead of ordering groceries online, and they will still waste their time on unimportant things. You need to talk about a story to get your head in the right place.

Bayesian statistics is notoriously known to be one of the harder concepts to grasp, and yet - it is a useful and powerful tool for any data scientist. In this talk we would cover basic bayesian concepts, and demonstrate how you can apply bayesian statistics to your project with the conjugate_prior pypi module, and pystan.

Gwen Shapira will share design and architecture patterns that are used to modernize data engineering. We will see how Apache Kafka, microservices and event streams are used by modern engineering organizations to efficiently build data pipelines that are scalable, reliable and built to evolve. We'll start the presentation with a discussion of how software engineering changed in the last 20 years - focusing on microservices, stream processing, cloud and the proliferation of data stores. These changes represent both a challenge and opportunity for data engineers. Then I'll share some practical suggestions on how to design future-proof ETL given those changed.

Everyone starts the same way when they need to handle a scheduled task: you let *nix Cron to handle that “easy” task. You then realized that you need to move data from here to there at some given time, so you continue sticking to the same *nix Cron approach. But as the business growth, handling scheduled tasks for different missions at scale becomes a concern with too much complexity: * Task logging * Task timeouts * Retries on failure * Task priorities & SLA * Task duration history * Notifications on task error * Task dependencies (fan-in / fan-out) * Task Modularity * Parallelize tasks In this talk we will take a deep dive into Apache Airflow, and how it helps us solve that complexity.

In the past, bash was gluing external commands together. Today we are mostly gluing APIs together. bash has stagnated and does not allow to work with APIs easily. Core functionality such as working with structured data is outsourced to external commands. This is not optimal and not convenient. NGS (Next Generation Shell) aims to be a language and a shell for today's systems engineers: structured data, sane error handling, and other features one might expect from a language that is being developed today and not decades ago. NGS is more specific than general purpose languages such as Python/Ruby/Go. That means syntax and semantics for common tasks such as running external programs.

In August 2017 Google’s DeepMind and Blizzard released the SC2LE - making Starcraft 2 an AI research environment. This was after they beat the best humans in GO. How hard can a popular RTS game be, right? Turns out - very hard. But modern AI techniques are getting increasingly better at tackling more complex and open ended games - so good in fact that the world records in many classic games are now held by bots. In this talk we’ll cover the main historic steps of AI progress in the domain of games - from simple challenges like Chess to harder ones like Mario Kart (yes, in that order). Last, we’ll see why solving execution-focused games is an important precursor to future AI applications.

Your team’s growing, and that’s awesome! But that also means it’s starting to lose some of the _fun vibes and close relationships_ of a small startup. You might’ve noticed that: * Everyone knows a lot less about one another * Teammates feel uncomfortable asking one another for help * New employees find it harder to blend in * Small cliques are forming, and some might not welcome “outsiders” **Don’t worry!** That’s normal, but there **_is_** something you can do. In this talk, I’ll explain how we implemented a “Lunch Roulette” to help ease the pain of growing from 0 to 100 team members in two years, how it strengthened the personal connections inside our team, and how you can have one too

Developing cloud native complex systems is a multidisciplinary challenge, combining frontend, backend and data plane components with a wide variety of devops and testing complexities. Dealing with these challenges requires a wide set of tools, languages, design methodologies and a solid delivery methodology. How do you establish a team and create a common basis for communication and culture allowing for successful integrations? In this talk we will overview our experience at Iguazio growing an R&D group from 5 to 75 developers in ~3 yrs, working with more than 5 (development) languages and distributed between multiple sites and time zones.

Are you a socialist? capitalist? How would that affect your code and your business decisions? In this talk we will go over some coding style, algorithms and business decisions we make every day and see how they apply to the real-world economics and to being libertarians, socialists and communists.

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

Software development is a process comprised of decisions made by the developers. But despite the the fact that some decisions can have a long-lasting, crippling effects on our app, we make most of them based on guesses. But what if the best decision is indecision? What if You could postpone most of your decision until you gather enough facts in order to make the optimal one? In this talk, we will learn why deferring decisions can result in a much better, simpler code base. We’ll see examples of decisions we think we have to take on day 1 of the project, yet, can (and should) be postponed and see how practices like Spikes and the right design of your application will allow that to happen.

Cloud monitoring is a complex thing and several successful startups and services are out there to meet your needs. As you grow, you will find that the cost begins to outweigh the benefit and you will be tempted to search for an alternative. I would like to share how we migrated from Datadog to a scaled open-source solution, as a combination of Prometheus, AlertManager, Grafana, and cut our ~2000 host setup substantially while improving our observability at the same time. I will also present some in-house algorithms for smarter anomaly detection using nothing but Prometheus!

Many devs are familiar with Clean-Code-Architecture, Design-Patterns, SOLID. DRY, KISS and many other good coding practices but very often they take it to extreme or As-Is and miss the fine real life balance that needs to be done when applying those practices. In this talk I'll demonstrate such mistakes like "Over-Reusing", "Everything is Generic" , Adapter Syndrome, "Following Status Quo" and others. This talk is based on my experience at the 6 workplaces I've worked at in the last 10 yrs, alongside 100's of developers, infinite hours of coding and reviewing others code, 10's of real life commercial codebases in various roles ranging from Developer, to TL , ML Researcher and Architect.

Debugging to Programming is like porn to internet: it accounts for the majority of consumed time, yet almost never discussed. It is almost never an official part in university/college training, and rarely even asked about at job interviews. How might a systematic debugging course look like? Can we define it as an engineering discipline? Can we extract some core principles that are valid across platforms and technologies? In this talk I'll survey some of the (admittedly very thin) accumulated research, share my personal answers - and hope to dedicate time to listen to yours. We'll do 1-2 examples as time permits.

This is a lightweight, (hopefully) entertaining talk, in which I will present insights and anecdotes from my studies in a laboratory that combines artificial intelligence with human-computer collaborations, and how I got to intentionally stumble into people. This talk will include a call for innovations in the border between humans and computers.

Writing too many hard-to-maintain tests is a super easy way to start hating the testing concept altogether, lose confidence and then minimizing it to a non-existence level. In this lightning talk, I'll try to cover the most important rules, reasonings and mindset that will set you on the test-loving path.

Users want to see their data fast, immediately, now. Whether you’re working with an ORM or writing native SQL, you probably had a “scratching-my-head-trying-to-figure-out-why-this-query-is-so-slow” moment. The team at EverSQL analysed more than 30,000 SQL queries from thousands of different companies, to lay down the most common mistakes developers do when writing SQL queries. This talk will focus on writing SQL the right way, the fast way.

In 2015, we've decided at Wibbitz to share our amazing technology to the world of storytellers and disrupt their world entirely. No more need for human video skills, here comes our amazing video creation technology that will allow ANYONE to create amazing videos, 100% automatically, using AI and NLP. We failed completely. but then we figure it out. In this talk I'm going to cover the shift in mindset we did toward AI, and also to discuss about AI and creativity. Can bots create a creative video? Can computers be creative? Lastly I'm going to suggest how each developer can take this approach to their next product and how it can eventually empower humanity to be creative.

Good automated tests make for high quality code, but more tests mean more code and more code means more bugs and more bugs mean more tests and more tests mean more code _ARGH!_ Let’s offload some of that work to someone who is eager to do it for us - a type system - and delete some code together!

You have decided to work with Off shore and distributed teams? great. Now what? Managing Off shore and distributed teams has lots of challenges. It’s easy to feel disconnected from others, run into communication problems, time zones issues and when you add cultural differences into the mix things can get complicated quickly. After this session you'll have more understanding, insights and tips on offshore and distributed teams management.

Serverless simplifies development and deployment, but typically also comes with low performance, usability and observability challenges as well as cloud lock-ins. Nuclio, a trending open-source serverless platform addresses first-generation limitations, is 100x faster than AWS Lambda and can be deployed in any cloud, datacenter or on your laptop (with Docker or Kubernetes). Yaron Haviv will go over the drawbacks of first generation serverless architectures and will explain how to overcome them with Nuclio’s unique architecture and features. The session will include a live demo showing how to write and manage a fast serverless app from scratch.

I've always found deploying a cluster management service to be a very annoying overhead to any distributed system. It's often the source of production problems, and requires additional resources that just don't really do anything. Each cloud provider has a queue system (Kinesis for AWS, Event Hub for Azure, etc.) and most production deployments include a Kafka cluster. In this talk, I'll show how we created a "headless" managed cluster using a distributed queue system, which reduced cluster deployment overhead while increasing visibility into what's happening in the cluster.

You probably keep a backlog of features you want to develop for your product. Likely many of them came from user requests, top-down decisions you are not sure will make a difference, and some bugfixes you hope to never get to. But how many of them are your Next Big Thing? The one that will really make an impact and transform your product from Cool to WOW? In this talk I will present an offline tool designed to imitate the online Via app, an on-demand shared transport system, but one which is omniscient and thus can give a perspective that the online algorithm can't. We use this tool to discover ideas for our Next Big Features, which is why we call it our Insights Generator.

Harnessing lessons learned from both Spotify and Netflix to build a company structure of loosely-connected-highly-aligned small independent squads. These squads are self sustained, containing devs, product, UX, marketing and musicians, and set their own rules and plans. In the talk we’ll share what squads we implemented and why we decided to go this route (vs. “departments”), along with real-life examples of the wonderful benefits and the not-quite-as-wonderful challenges.

Disaster Recovery (DR) is like an earthquake. We all know it will happen. We just don't know where and when. But don’t panic!! I will share with you the processes, tools and architecture changes of making the DR process shorter, automatic and most important: Without panicking!

Describing the history of the Open Source community. From Richard Stallman initiating the Free Software Movement and GNU in 1983 till these days when almost every big company feels obligated to donate to the open source community and speculating about the future. Special attention will be given to different open source/free software licenses and the differences between them.

Part time work is great. It enables people to work while spending more time on their studies, family or startup. But it also comes with challenges. How do you manage your tasks and time when you're only working 1, 2 or 3 days a week? How can you make the best of your time at the office? If you have a part-time team member, how can you benefit from their expertise, without getting stuck waiting for their input? Also, managing yourself as a part time worker is hard, managing a part time worker is just as hard. How should your management style and expectations change to enable them to work efficiently? In this talk I'll share my experience, and hopefully some answers.

Not all microservices are bug free. Actually, most of them have some hidden bugs. Some of those bugs may even cause your microservice to hang, or to return unexpected responses. Will you wait until the next production crisis just to find out about it? We, at eBay, took the proactive approach. Meet *Watchtower*, a monitoring/alerting system that periodically checks each host in the pool for expected responses as well as latency. In this session, I'd like to describe *Watchtower*'s high level architecture, its pipeline, and its visualization. In a nutshell, it saved our asses (more than once!)

Opsschool is a shared effort by leading companies in the "devops" culture to train new "new-ops" engineers. we will talk about the motivation for building opsschool (more than you think), the benefits, and what we want to achieve. we will talk about responsibility and accountability as tech leaders in the industry.

Building an organization that’s autonomous was one of the founding principles of Lemonade, and Cooper, Lemonade’s internal bot, is the perfect example. Hear how the most hardworking, fast, and smiling dev team member drastically removed dependencies within our organization, increased efficiency, and empowered the non-tech members to perform tasks that are usually designated solely for tech team members.

I just needed to optimize my time. I have so many errands to run. I always find myself going to the Post-Office, or going to the Bank or Pharmacy - I needed something to help me tun my errands. So I build it by my own. Happen to be that other people like it. I had no idea. I found myself developing Mercedes.Me next Digital Assistance.

Many times we, as Developers and Product Managers, see features or products that aren't being utilized well, or don't fit in with our product or engineering vision, but we keep them just because they're already there. In this session I will introduce signs to identify when it’s time to let the feature or product go and share best practices on how to "have the talk" with the feature. We will review examples of companies who removed features/products and show how, in many cases, removing features improves your product, your offering and you.

Big data is a challenge that requires lots of specific skills, experience and devops. We identified that one of the main issues causing this is data management - making sure all your data is available, inexpensive and usable. By leveraging cheap storage on S3 and an immutable data lake, we managed to enable developers without specific big data skills to work with data at any scale, without skyrocketing costs. In this session, I'll describe our data lake architecture, and how it supports a large variety of data use cases without increasing costs beyond the basic cost of data storage.

In our first iterations of developing Conjur, we didn’t know yet what the product would be, so we built a bunch of different microservices that were loosely connected, and sometimes we just abandoned ones that didn’t work out. While this optimized us in certain aspects such as flexibility and testability, we were not optimized for hiring and ramping up new team members, performance and transactionality. In this talk we will talk about the process of consolidating some of our micro services: a deeper dive into the issues we had with our old architecture, what exactly we did do to solve them and the fabulous outcome of this process that includes a x100 performance improvement.

As product managers, our biggest fear is creating a product that nobody needs. So, how to make sure your users will want your product? In the B2C world, you have to be both data-driven and customer-centric. To make your product better, you need to: 1. Collect input from users 2. Understand why users churn or stay 3. Apply that data using MVP and fast iterations We tried at Soluto different ways to collect data in the right time and context. I would like to share with you what we did and learned in the process, show methods to collect user input, what worked and what didn’t. I will also showcase examples of how to use the data and create a product your users will actually use - and love.

If you ever worked on a large web project with a big development team you likely have experience with continuous integration. pushing a code to git automatically goes to staging or production server! How about mobile? React Native mobile projects? Setting up a CI system for mobile iOS/Android helps ship updates more often with zero effort! It also helps to test the outcome and streamline the entire development process. In my lecture, I'll go over the parts we use to streamline the development cycle for mobile using tools like: prettier & linting, unit tests, E2E tests and further to Github + Bitrise + Hockeyapp or google play / apple's app store for distribution.

Stop writing code for every feature! As funny as it sounds, focusing on the core business is not always trivial for dev teams. There are always distractions, bottlenecks and non-core features to develop (ahem ahem, GDPR). We are going on a short tour where you’ll see how to answer various product and R&D demands without breaking a sweat, minimal writing of code and zero(!) maintenance. By the end of the session, you’ll be allergic to writing code on menial tasks and save it for when its really needed. You’ll also learn where to get “inspiration” and learn about more tools.

Bio-Inspired algorithms such as Genetic Algorithms and Swarm intelligence can be competitive alternative for Training Deep Neural Networks for Reinforcement Learning. My journey in this domain started 10 years ago by building a RL-DNN bot that compete in a 3D racing simulator named Torcs. (demo available on my Youtube channel) - In this talk I'll show a different approach to train a deep neural network that can drive and control a racing car that outperforms a human driver in simulated racing environment - laying the foundations to try and solve any kind of RL problem differently.

Working software , Individuals and interactions base for Agile developers. In my view the Team commitment and joint work are the key to the success of any project. One way to achieve this is a "clean code" .As Uncle Bob said , if you needs to clean behind you even if is not your code. In this talk I am going to give a real life story. My life experience is based on dozens of projects over more than a million lines of code. I met all kinds of developers. Together we can reduce the Technology debt

Programmers can help social community a lot. There are many non government organizations that need software for their "clients". But such organizations don't have much budget for this effort. We, in Hitech community can help such organization. I will describe how we, in MicroFocus, wrote several projects for the community. I will urge the people that hear the lecture to join this effort with me or within their own company.

Our product wasn't complete without this one feature, so we went ahead and built it. Soon enough we came to realize users didn't use it, and even worse, they were still feeling the pain we planned to solve. We ended up finding ourselves in a situation where we had to rebuild a fresh feature from scratch. This experience thought us some good lessons that would should be heard by anyone building anything.

Let’s face it, recruitment is hard. We want only the best engineers to join our incredible team. We, as interviewers, have a leading role in the recruitment process as we have to assess whether a candidate is a good fit for our team. We sometimes forget that we have significant impact on the interview’s atmosphere, which can greatly affect the candidate’s performance. This short lecture will pinpoint some of the things that you, as an interviewer, can do to make the interviewing process a lot nicer for candidates (and yourself). Ultimately, helping them be at their best and therefore, making the decision a lot easier.

Disneyland is a place of magic and wonders, but more than that it’s a prime example of how to make an product which is much much more than just a product. Because the product Disney is selling is not roller coasters or Mickey Mouse dolls, it’s an unforgettable experience. And it’s no surprise, as Disneyland is meticulously and deliberately engineered to be fun, engaging, and a little bit whimsical. They even have a special name for this group of people, who combine the skills of engineering with imagination, they call them Imagineers! In this talk I’ll share five Imagineering tips from behind the scenes of the happiest place on earth on how to create a magical experience for your users.

Executives and business people are swayed by the hype that AI & ML is an all encompassing savior to digital transformation challenges of scale, complexity and rising costs. In reality, operators and technical decision makers have a hard time letting a machine automatically take action on their mission critical business applications and services. With the Open Box machine learning approach, ML is no more a black box! Applying it correctly helps users gain confidence and ultimately trust an autonomous system. Such a system leverages approaches that span the automation maturity model, including manual, assisted and fully automated capabilities that the operator uses in their daily workflow.

The world is going crazy, I’ve got thousands of emails about privacy policy update. Everybody talks about GDPR. Even Beyonce is less popular than GDPR these days according to Google. Is it good for the internet? Will it kill successful businesses? History will be the judge of that. But for now, every company HAS to deal with it even if it sounds like mission impossible. AppsFlyer SDK is installed on 90% of all mobile devices which makes us exposed to GDPR requests. In my talk I will show which challenges GDPR introduces to Data oriented companies. I will show possible solutions and what we ended up implementing.

Building IoT application are easy these days thanks to super smart cheap micro-controllers, which can be developed into a nice and sophisticated POC using basic development capabilities. But how should we provide a robust backend, admin capabilities and UI? Using leading edge frameworks we can build an end-to-end system and have a IOT sensors, backend and UI within a very short time and effort. Let’s also consider data collection and aggregation, business analytics, logging and monitoring to run your business. I am going to build that application LIVE in Python, using Raspberry Pi and Python Flask.

For those of us watching and enjoying Westworld, it’s difficult not to see the analogy to edge computing and devices with an intelligent networking mesh tying all the pieces together.   With the world moving towards billions of distributed yet connected devices at scale, there are quite a number of challenges to making it all work in the real world. This talk will take some lessons from Westworld, and demonstrate how you can learn from their mistakes when building your edge architecture of interconnected devices.

We all know and love the SOLID principles of object-oriented design, as explained in depth by "Uncle" Bob Martin, Martin Fowler, Kent Beck and others. In this talk, I will demonstrate how to achieve the promises of SOLID with pure functional paradigms. I will describe how I abandoned the familiar OO patterns to model a new service at Wix, and found that most basic form of abstraction is the function. Finally, I will enumerate the benefits and the tradeoffs, and how this changed the way I think about software.

In late 2016, StackGAN was the first generative text to image algorithm to show photorealistic results conditioned on the textual input. For many practitioners this work felt as being ahead of its time by one year. A few recent papers improve upon this, one of which is AttnGAN. I have used the latter to develop a novel real-time speech-to-image visual poetry machine called "Pictures of Jap Girls in Synthesis" (https://www.youtube.com/watch?v=lSFoQcqhbfU&list=PLZV8sKAO3LzZ4dxF57JbSiUj4CTqVBHd1). I will do a lightning review and introduction generative text to image methods using deep learning, while using the visual poetry machine for a live demo.

For many recommender systems users and items are 'embedded' within a latent vector space. The closer the user and the item are in this space, the higher the probability for the item to interest the user. In this talk, I'll describe the pain points and solutions for using embeddings in a high-throughput search based recommender system . From coping with cold start users and items that require on-the-fly embedding generators in serving, to keeping up with the dynamic nature of embeddings that change rapidly with every chunk of new supervised data. We'll cover batch indexing and incremental indexing setups as well as a solution for parallel AB testing of multiple embedding schemes.

You can have more time with your family, with your partner. Have much better life balance. More time to yourself. All this while having higher efficiency at work, and higher quality outcomes. I discovered this is possible through remote working. I also discovered **it is** for everyone, as I moved one day a completely regular, in office company to be a 100% remote company. In this talk I will tell you about the process of transitioning to remote, and how it affects and changes communication and work. I will tell you how remote work can completely change your personal life. And I will also tell you how to do it part time, if your company isn't remote yet.

Serverless is at its peak hype. It can accelerate dev, simplify ops and save costs but also comes with many limitations such as short lifespan, slow performance, limited observability and lack of standards. This session will review current solutions and use-cases to demonstrate how to bypass serverless limitations and build complex applications. It will cover future development visions and standards which will impact your architecture with live demos and hands-on examples. Yaron is the co-author of the CNCF Serverless Paper/Standards, the co-creator of the nuclio open-source serverless platform and writes blogs and tutorials about serverless for TheNewStack, Hackernoon and DZone.

Building a solid connection between product and R&D is the key ingredient for building successful product. While some may consider this an inherent conflict between two forces, I see a beautiful opportunity to grow together and build solid products as a result of solid connection. In this session I will present 5 lessons I've learned in the past couple of years and will give you day-to-day tools on how to build a solid relationship between Product and R&D which will make your product and day to day lives a bit more awesome.

What works at first, may not scale later. Undertaking a massive product architectural change is not an easy feat - it’s like changing wheels of a moving vehicle. Nevertheless, that’s what we did at Culture Trip: we modernized our front end and decoupled it from our Wordpress site, all while growing as a company, maintaining legacy code, delivering new features, recruiting new talent, improving our work process, teaching new technologies and making sure our team of over 300 world-wide contributors could keep on creating and we could keep on developing. This is the story of how we made our product scale to support over 15 million users.

Building a product is awesome - You take an idea and make it come to life but then you need to work with a product manager that doesn't understand anything you say when you talk code. When you have different product managers that come from different backgrounds we will try to answer the ultimate question- Do Product Managers Need to Code?

The internet offers an endless amount of simple online games like solitaire, minesweeper and hearts. However, these games are usually done with terrible UI/UX, lame graphics, full of banners and ads, and (dare I say it), built on FLASH. In this presentation I will talk about how I built a DOOM minesweeper game with React, Redux & Typescript. I will also share my dream to create one open sourced website, which will host many well-created simple games, to serve both as a learning platform for developers and for players to enjoy playing good looking games with a great UI/UX, without a ton of ads, all in one place.

We’ve all wished we’d have more hours in the day. There’s just so much we want to do! More topics to learn, more information to ingest, more data to sift through, MOAR of basically everything. We feel like we always have to do everything, keep up with everyone, be in all the loops and stay on top of all the things. Unfortunately, there is a finite amount of hours in the day. We find ourselves doing too many things, and not doing things well enough. At this point, comes a dreadful truth; we can’t do everything, and that’s terrifying. In my talk, I’ll cover some techniques for how to get the important things done, skip the less important things, and most importantly - how to tell what’s what.

In the last 3 years I've being taking an active part in building communities both on my free time & work. These communities (mostly about tech) made real impact on the industry & people lives: From mapping wild fires to save lives with the Air Force to raising mobile chargers prices in Israel (oops), making it into the MAIN news headline and (almost), and so much more... This is no magic, and there are many efforts behind the scenes. In this lecture I will unveil some of them and explain how we, at Wix, initiated a brand-scale global dev communities effort. I will finish with steps that anyone can do in order to take part in the communities world and enjoy its professional benefits.

Every developer ‘knows’ it’s important to put himself out there by building open source libraries. However, the majority of devs don’t do it. Why? What’s holding us back? In this talk I will talk about my personal experience and about the psychological barriers which are keeping others from going open source. In addition, I will go over what’s important when building an open source project in order to help your first experience go as smoothly as possible.

*This is an extended version of the [talk I gave](https://youtu.be/F2m1qR1zZc4) at Serverless Days TLV* **Serverless** is a a very convenient way to quickly write and deploy code, but not having a server with shared memory and/or disk storage makes stateful flows hard to implement and analyze. This session will provide an overview on the different approaches for achieving this (queues, orchestration services, etc.) and go in depth into one of them - AWS’s **Step Functions**. We will see how state, scaling, error handling and parallelization can be achieved via configuration and also discuss drawbacks and which use cases are a good fit for Step Functions.

We hear about account abuse and credential stuffing all the time. Let’s dive into some code and see why this is so simple, and what is the problem you need to address as an engineer. In this talk, we will explain why this is so common by exploring examples from our datasets and going through the entire process, targeting a demo mobile application. Starting from reversing the APK up to running the automated fraud. We will also cover some approaches to protect both the business and the consumer from such attacks

A/B testing is the foundation of data-driven decision making. In today's world, when advertising becomes crucial to a website's revenue it is even more important to measure the effects of changes correctly. We will show how to correctly design and implement an advertisement A/B testing. We will walk through pitfalls, potential biases related to advertisement metrics and possible mitigations.

After coming to the realization that our backend system cannot scale for much longer and that new features are very difficult to add, we decided to write it from scratch. With hundreds of thousands of users actively engaging our system, we don’t have the privilege to start over and grow slowly. We rewrote the applicative layers while still relying on the old data store and then wrote a new db and app stack layer, replacing the legacy one piece by piece. We implemented a migration system that is *always on*, meaning that every change in the old system makes its way to the new system, making the two systems eventually equivalent. I will discuss the challenges and lessons learned.

What if I told you that not all managers know everything? This lightning talk shows my feeble attempts as a technical engineer manager to not be overwhelmed by my smart minions. In addition, the session talks of how a manager can bring value even without taking a pause to get a P.hd in every field the team members are experts in.

As front-end developers, we often neglect the performance side of the application we are developing. Having an application that loads very slowly can cause our product to fail. Sometimes, we may not even know about those problems because of our local development setup. As a front-end developer at Wix, I have been facing performance related challenges constantly and learning from them. In this talk, I want to share my knowledge about those problems and explain best practices for solving them. We’ll do it together by opening a site, inspecting it and solving performance problems, one by one.

The Orleans framework has taken the "Actor Model" concept to build reactive , event-driven, middleware framework that allows the building of scalable, high-throughput, low-latency and highly available systems. All are difficult goals to meet with the traditional stateless 3-tier architecture or managed container based micro-services. Orleans uses the Actor Model to raise the abstraction level that decouples the business logic from the low-level constructs of such systems allowing the developer to focus on application logic. In this tech talk I'll explain and share my 2yrs experience with Orleans.

In this talk I will try to show you how DDD (Domain Driven Design) can help us solve some of the hardest challenges in architecting a micro-services based eco-system: 1. Making sure that things which change for same reason are co-located inside the same Microservice. 2. Elegant and efficient event driven integration of microservices (Domain and State Changed Events)

A lot of developers use git on a daily basis, however don't understand how it works, and familiar only with the basis options.. I want to talk about this great tool - and present these subjects: - HEAD pointer and commits hashes - git rebase vs git merge - git cherry-pick - git bisect - git reset

AWS-Least-Privilege is an open source tool that aims to streamline the process of collecting resource usage information from X-Ray for reaching a "Least Privilege" security posture for a serverless application. AWS X-Ray provides in-depth information about service API calls. Using this information, the tool is able to build a profile of the AWS resources and actions that are used by an application and generate a policy document reflecting it. Additionally, the tool can compare the generated policy with the current active policy for continuous monitoring and alerting purposes. Project page: https://github.com/functionalone/aws-least-privilege Intro blog post: https://bit.ly/2IVCZxw

Many corporates and big companies have “Annual Summits” for developers, but what happens when you want to participate in one while working for an early/mid stage startup? The “Integration Day” which we introduced in Singular - is a great opportunity to collaborate and build a friendly startups community by having a small, intimate conference with similar companies facing the same challenges (like culture, tech-stack and methodologies) , including sessions and round-tables. After having 6 (!) Integration days with 12 other companies I would like to share the model, lessons learned and some recommendations about having your own Integration Day!

Reactive programming is about writing responsive, resilient and elastic systems. It's an event-based architecture for asynchronous handling of data streams. Project Reactor is an implementation of the Reactive Streams standard. It's become the core of Spring 5 (and consequently Spring Boot 2), and the ecosystem around it grows ever larger. It's a powerful and very expressive paradigm for implementing non-blocking behavior, but involves a non-trivial learning curve. The session will introduce the core principles of reactive streams. We'll go into the details of how to implement and test for realistic use-cases applying the reactive programming paradigm. (code in either Kotlin/Java/Scala)

Soluto is made up of product teams, which are great for quickly delivering features and driving the product forward. This is also consistent with our core values of independence and responsibility. However, the focus of product teams sometimes makes it difficult to pay off tech-debt, improve non-functioning aspects of the system, and integrate the latest development tools and technologies. Over the years, we attempted to tackle this problem in a variety of ways. In this session we'll learn about the various solutions that were tried (and failed) until we ended up with our current solution: platform teams.

Continuous Delivery is a big trend today and for a good reason. Nevertheless, there are critical steps down the delivery pipeline that many organizations miss - post deployment monitoring, analysis and possible roll back based on the results. In this presentation we would like to share how we utilized Spring Cloud Pipelines and Concourse in order to build, test, deploy and monitor the deployed services. Our solution has enabled us to inspect deployment processes across multiple environments and data centers using the blue/green deployment technique, gradually ensuring zero negative impact on production when deploying a service.

Redesigning a new architecture to an existing product is a tough decision. But tougher than that is to maintain the current version while building the new one, and do so in a way that makes it seamless for your clients and efficient for your teams. In this session I will discuss four possible solutions to that problem, based on my experience in a few companies.

In this talk I’ll use concrete code examples to explain the concept of parametricity. This is a core concept in Functional Programming. It’s also the basis for the claim that writing Functional code is less error prone that writing Object Oriented code. I hope that understanding parametricity will enable the audience to assess this claim, and make up their own minds about the benefits of Functional Programming.

Apache Kafka is commonly used to centralise log and event ingest from across an organisation. With its built-in stream processing capabilities, it's possible to easily process this data in real time. In this talk we'll see how to use the open-source Apache Kafka and KSQL projects to ingest syslog data into Apache Kafka, and then process it with KSQL. KSQL provides a SQL-like language for expressing stream transformations, making it easy for developers to develop powerful stream processing applications and pipelines. As well as exploring the power of KSQL, we'll see a simple example of a microservice to drive alerting based on events from Kafka.

What is non-blocking IO, how does it work, and how can you increase your throughput by a few orders of magnitude. What is the C10K problem, and why can't we just add more threads? I will also speak about when it's worth the extra complexity price, and how can you get there relatively easily.

All of us have seen how image morphing looks like - how an image of a child is morphed into an image of a tiger. Can you imagine what would **word** morphing be like? In this talk I'll show you how you can use the combined power of AI and Machine Learning to implement word morphing yourself.

Adding an Admin screen to your application can boost its functionality and make your product flexible and easy to change. In this session, we will see good and bad examples of how to build Admin screens and learn how to create one that can be as smart as Einstein, with different functionalities without it becoming Frankenstein!

Know what it's like being an engineer for 22 years? Someday you will, but in the meantime, this session will share 11 important lessons learned from 22 years of engineering. Having built products for 4 startups (all of them still active!), 2 corporations (2 IPOs!), and one of the engineers who built Lemonade, you won't want to miss these insights.

"Mutable stateful objects are the new spaghetti code" --Rich Hickey In Java most classes are mutable and that's the default, so that’s the way that most Java developers write code. In this talk you’ll see why mutable code fails: though easy and fast in the short term, you end up with a complex mess that's hard to understand, test or reason about, and is a concurrency nightmare to boot. Finally, we'll challenge the prevailing paradigm, exploring how simple immutable objects excel in these same cases.

As a developer, do you want to be a generalist or specialist? The answer is not the same for everyone. It depends on your traits, the company you work for and even how long you are a software engineer. I was a java BE developer for 15 years and then switched to be a generalist. I did everything from web and mobile to BE, data and ops. Being a generalist does not fit everyone but if it fits you it is a hell of a ride. If you are considering being a generalist this is the talk for you.

Moving a dev team from scrum to kanban is a painful process, yet not impossible. It raises questions and concerns for all stakeholders such as PMG, TL , Operations, Developers, QA and support. In this talk I will tell our team's story around this journey, what was the difficulties and what went well.

Apache Kafka is a distributed, scalable, and fault-tolerant streaming platform, providing low-latency pub-sub messaging coupled with native storage and stream processing capabilities. Integrating Kafka with RDBMS, NoSQL, etc is simple with the Kafka Connect API, which is part of Apache Kafka. KSQL is the open-source SQL streaming engine for Apache Kafka, and makes it possible to build stream processing applications at scale, written using a familiar SQL interface. In this talk we’ll explain the architectural reasoning for Apache Kafka and the benefits of real-time integration, and we’ll build a streaming data pipeline using nothing but our bare hands, the Kafka Connect API, and KSQL.

Memory leak in a critical service. A new feature that requires exploring new technologies. Marketing team needs a new internal tool. A new requirement from a client rises the bar on what the application could do thus far. Unexplained performance degradation. Who will usually pick that up ? an experienced engineer? the 1st startup engineer? Who ever is available? What I suggest is that it is possible to design, from the ground up, the perfect Special Forces team to do just that in an optimal way. It just needs to be designed and planned, and not just happen randomly ...

About a year a go we decided to move from AngularJS to Angular, after 1.5 weeks of development and refactoring we were live in prod. Result were: 0 bugs, 0 down time and most important 0 time was spent on QA. In the never ending progress of Front-End frameworks, you need to iterate fast without breaking your app. In this presentation I want to show the pipeline we built for our web apps, this pipeline gives us very fast way to reach production with very high confidence that no bugs reached production, We will talk about development, testing, build & deployments and how to combine it all to one bullet proof pipeline.

We at Satellogic capture imagery of earth using our constellation of satellites. We share some of our data in what we call Social Impact plan. You can find description of this plan [here](https://github.com/satellogic/open-impact): In this session I would like to present this plan, and guide how anyone with a bit of development skills can use our data to make social changes. The session will have some code examples in python

For OSI's 20th anniversary, I've reviewed what happened in Israel regarding Open Source. The two main aspects would be the innovation created here and the companies built based on it vs. the government policy and adaptation of (or lackof ) such technologies by the "startup nation". Two interesting segments would be virtualization and databases, which receive a lot of attention by Israelis in addition to our "default" field of (cyber) security.

Monitoring is important - but as your company grows it becomes harder to keep an eye on all the different moving parts. As the times roll by and the company grows new technologies are being added to the stack and it’s essential to make sure those can be monitored reliably out there in the wild. We want to share how we transformed monitoring from a one man job to something every developer and Product Manager cares about and actively participates in. This talk will introduce you to open source tools that can enable such a solution. Walking you through a cultural transformation that makes monitoring accessible to everyone.

At Soluto, we use MVPs to create and iterate on existing features. We have also begun using it to rethink our core products and rebuild them from the ground up. This strategy changed the experience for not only our users, but also ourselves, and has led to disruption within a 17K person org. In the talk I’ll share how rebuilding one of our products included a unique set of obstacles– from challenging the organization to on board with new work processes, to rethinking how we develop products, to getting users to realize the potential of a product that differs from what they’re used to. Such an approach also requires patience and trust in a process that takes time to lead to a mature product.

Agile and lean methodologies considered to be an opposite of through research. In this session, we will walk through the differences between agile definitions and data-science and try to decide whether they can long-live together. We'll start with why the can't - as trivial as it sounds - the tension between quality research and business stakeholders was never bolder. Then, we'll see methods and best practices to connect the two - Human-in-the-loop patterns and usage of active learning (for small-scale problems) and transfer learning (for more complicated ones) to allow more efficient research while really balancing time, business value and not compromising the research quality.

At Gong, we have over a dozen different live machine learning models in multiple domains (NLP, audio/speech, video and classical ML), used in practice across hundreds of enterprise customers. We will review how those models are built, evaluated, deployed and used in real-life scenarios. We will outline different types of models (domain-agnostic vs. domain specific, supervised vs. unsupervised, deep learning vs. classical ML), and cover how data is obtained, how the models are evaluated (pre and post production), and how they’re used for new predictions. We will show case studies of data flows and pipelines, and discuss where humans (general labelers + domain experts) come into the loop.

Have you ever found yourself spending hours looking for the right tool for the job? Or found yourself with a tool that doesn't do exactly what you need? Often you should just force your problem to fit the tools available. But sometimes it's time to bite the bullet and build exactly the tool you need. That's what I ended up doing when I needed to analyse the shape of BigPanda's traffic on our Kafka topics. I ended up with exactly the right tool for the job, and found myself reusing it again and again. In this talk I'll talk about what I learned. When is it time build a tool instead of buying one? What are the hidden benefits? And when is it just a bad case of 'Not Invented Here'?

Product managers should heavily rely on their team to make daily decisions in order to help them focus on the long-term strategy. A product manager should involve their team in the discovery process and the ideation. It really doesn’t matter who makes the decisions as long as the decisions taken are the right ones and the right ideas are promoted. In this talk, I will try to explain why it is important for the development team, how developers can benefit from such approach, and what in it for them. Product managers should take a great team that already delivers great value and help focus them even more and achieve greater things. As engineers, it’s your job to help them.

I met Ofri Raviv in a PyWeb-Il meetup nine years ago and talked him into starting Open Knesset. Ofri took the BDFL hat and I took charge of the front-end and community development, starting a weekly dev meetup begining on my roof and than at google's campus. Open Knesset was a wild ride, including 4,243 commits from 73 contributor, meeting with Rivlin, the Knesset Chairman, a consulting contract and a bribe offer. Eventually we ran out of energy and The site is down since May 2018. Riding Open Knesset, I learned a lot about the Israeli Democracy, community development and gov.il software and in this talk I'll present the mistakes we made and the lessons learnt.

I intend to claim that your future backend framework will be Kubernetes. It will be hard to establish such a bold claim in just 30 minutes, but my hope is to intrigue you enough to make you look it up and see that my claim is correct. I will show how Kubernetes relates to everyone's current backend, what it tries to achieve and how. I'll demonstrate a complex microservice environment deployment, briefly presenting the Kubernetes abstractions that makes it a manageable one line command deployment. Lastly, I'll present some of the interesting hot technologies in the vast Kubernetes eco-system, like serverless over Kuberenetes and machine learning over Kubernetes.

When starting to develop deep learning modules a lot of time will be wasted on managing resources. You need to setup a machine with the proper frameworks and the proper hardware, wasting many patient cycles when you just want to kickstart and check and idea as soon as you can. Today we have several ways to focus on your idea without wasting your time in server setup and management, Google AutoML allows you to take your data and get results immediately, Amazon Sagemaker (and Google CloudML) get take your module and run it without worrying about server and platforms.

Ever wondered what's the biological difference between a short summer crush and a life-long romance? Or why we get tearful at our best friend's wedding? And what does that have to do with how users fall in love with our product? We often hear that we should "get users hooked" on our product. Asking them to love it can be much harder. In this talk, we'll show how the hormones and neurobiology of the brain can make us TRUST and LOVE a product with a meaningful relationship, rather than just get addicted to it. We'll learn how some of the best products in the world use our neurobiology to make us love them, and try to create a useful toolbox of knowledge we can use in our own applications.

The Google "20% time policy", though faced with endless criticism about what happens when reality kicks in, remains a sort of Holy Grail in many organizations. Isaac Asimov famously noted that the great ideas came as side issues, by people who were paid to do other staff (if at all), Following several years as a lecturer for SpaceIL and an Innovation Agent at Amdocs, in this session I'd like to present yet another take at this challenge - volunteering. If your idea is important enough, be it sending a spaceship to the Moon or spreading new innovative methodologies, you might just want to set the ground rules and start experimenting: only value-generating parts (for all sides) would stick.

Planning a project was usually one of those tasks we referred to as some kind of overhead or tax - a bit like testing, or quality, or innovation. Just like all of them, we tend to see today that it can't be someone else's job, but a part of the ownership of every individual in the organization. I can't refer to "My Excel" as "The plan" and everything else as "Whose Plan Is It Anyway?". It won't hold. In this session, I will present a different approach to planning projects, when there are no projects anymore (a defined beginning and end? clear scope? budget? schedule? did anyone in the audience ever seen one in real life?), and why this translation should be part everyone's job.

Each of you probably quoted Conway's Law, or Murphy’s law more than once during his career. Did you know that there are many other quotes you can and should be using? Quotes and adages are great in capturing insights and defining a common language - kind of like Design patterns are. So, are you going to stick with only Singleton and Factory in your arsenal? Knowing some additional quotes, the ideas and anecdotes behind them can help you harness industry insights in your favor! But not only that, it would also make you look smart and funny along the way! In this talk I will cover some such “laws”, insights they capture, the rational and people behind them.

So some manager’s manager announced a re-org. Whether you’re an engineer, a manager, or a chief-of-everything-awesome, you’re probably freaking out, and you have every reason to. Changes are as hard as they are inevitable, both for the people in charge and for the people affected by it. You can either control the change, or let the change control you. As an engineer and an engineering manager working at a hyper-growth company, we’ve been through some changes and learned some lessons. In our talk we’ll go over this process together, figure out what’s so hard about it from a manger’s and an engineer’s perspective, and talk about some of the techniques we’ve used to ease the pain.

Have you ever wondered why your Node.js server works slowly ? In this talk I will give you tools to know from where you should start looking for problems in your Node.js server. I will go through general performance tips, demo some profiling in Node.js, and talk about Node.js and JavaScript Code optimisations that you should do. Hopefully, by the end of this session you will have the tools to dig deep and master performance optimisations in Node.

Value investing is to invest in companies that their stock price will bring value to their share holders With develoeprs salaries we can save a lot of money every month, invest it, let it compund for few years and allow ourself to retire earlier I can educate the audience on real interesting stories and pratical tools I can tell them my story

Building a good purchase flow for your users is a hard work. You run A/B tests to improve usability, use best practices to assure the quality and advanced UX to minimize user friction. Alas, all these method mean it’s easier for an adversary to build a malicious automation around your website. The growth around automated attacks targeting the cart and the purchase Flow is causing severe financial damage, loss of revenue, increased infrastructure costs, and even skew your BI analytics. This talk will cover examples of such attacks we uncovered, from scraping and hoarding to scalping, and explain what you can do to detect them and protect yourself.

I've shared more than 2000 posts on SoftwareLeadWeekly.com in the past 5+ years. To share these posts, I had to read almost 14000 posts during that time, which includes blog posts, videos, books and interviews (podcasts). I want to share some of my lessons learned about: - Which kind of "Growth Material" you should focus on? - Where and how to find great content (good value vs. noise ratio)? - How to set time for learning? (I'm a father of 2, I know how hard it can be) - How to consume knowledge X2 faster? Are you seeking ways to up your game? If so, you'll enjoy this talk.

It is increasingly important for engineers to work with data. The data scientist is the extreme scenario - but all engineers need to start growing a small data scientist, data analyst and data engineer inside them to be really Full Stack. In this session I will give some tips on how to become a more well rounded engineer by getting comfortable working with data with real life examples.

When we first started out it was a different world. We were running software on physical servers and automation was scarce. We moved to the cloud but that move does not automatically make your architecture "cloudy". In this session, I will share our journey to the cloud and most importantly within the cloud from the perspective of automation - what challenges did we face and the technological choices we made to overcome them.

Decentralized systems in general (and blockchains, in particular) hold great promise for solving hard social and financial challenges, such as: trustless store and mobility of value, autonomous organizations, programmable money and smart contracts, yet today's technologies aren't capable of handling such scale (e.g., Visa's 2500 TPS vs. Bitcoin's 3.3 TPS or Ethereum's 15 TPS). In this talk, I'll give an overview of some modern scaling approaches. We'll discuss the current state of blockchain technologies and what they're lacking and analyze leading scaling approaches, such as: sharding (e.g., plasma constructs), L2 solutions (e.g., state channels), and "alternative" consensus algorithms.

Writing too many hard-to-maintain tests is a super easy way to start hating the testing concept altogether, lose confidence and then minimizing it to a non-existence level. In this session, we'll overview some rules, reasonings and mindset that will set you on the test-loving path.

The first thing you learn when you start programming is how to write new code. The second is how to add functionality to it. The third is how to maintain it. The fourth is how to design your code so it’s easy to add to it and maintain. But when do you learn how to work with “off the shelf” code? Code that you cannot maintain, cannot redesign, cannot add new features to, and sometimes cannot replace. In my talk I will help you choose and work with “off the shelf” software, so you can grow easily with, or without it.

Many years of knowledge have been accumulated at creating companies around a product. We know how to build them, we know how to optimize them and we know how to make them scale. The same amount of knowledge does not exists for creating a company around data. In this session I will share some of our learnings, from ecosystem and well as personally around transforming the focus of an entire organisation to be around the data.

It all boils down to what task your model should learn to do. You just need to choose one loss function for your model to minimize, right? Well, it turns out you can train your model to learn multiple tasks at once. If you do that, most chances are your model will generalize better! In this talk you'll understand why introducing multiple tasks to your Deep Neural Network is helpful; You'll experience concrete examples of when it's effective to do so; And most importantly, you'll learn how to implement it.

Lately, Applitools submitted a major pull request to Appium, a popular mobile automation framework, adding capabilities for both iOS and Android, based on about a year's work of research. During this time, We've learned a lot about Appium's structure and the integration with the underlying automation environments. In this talk, I will dive into the Appium code, specifically the BaseDriver and its derivatives, and demonstrate how to add new, multi-platform capabilities, by inspection of the various plugin points which allow adding features to the different platforms. This presentation is based on a presentation originally given at Appium Conf 2018.

Do you use error reporting system in your software? How do you know whether those are your errors? How do you run your tests without throwing tons of errors to that system? How do you even test error reporting? My talk is about error-reporting in modern FED eco-systems. I’ll present our approach of how to scope and differentiate between errors in “multi-app” systems, and how to conduct testing conveniently and with no hacks. The story of how we solved it, I truly believe, would benefit and inspire others. Participants of this talk will be introduced to a new way of reducing the noise of their monitoring systems and understand why it is so important to have such a system in the first place.

Ever used a code kata? Looked to hire a ninja programmer? Installed a X-Jutsu plugin for you favorite IDE/Language? What is that with programming and martial arts? As a programmer and a martial artist I felt unsettled, so I went on a quest to investigate. I've interviewed a number of seasoned programmers, algorithm specialists, and other people working in software who are secretly martial artists. I've heard what martial arts taught them on coding, and what coding taught them on martial arts. (Based on a podcast due to be published in late May).

There are many aspects to consider when choosing a data processing framework. We @Juno chose the most dominant framework - Apache Spark (1.x). After a while, we started encountered a few issues, so we considered different solutions. At the end, we chose Google Cloud Dataflow. Google Cloud Dataflow is a fully-managed Big Data as a service. With Dataflow you can develop wide data processing patterns including ETL, both batch and stream computation with the same interfaces. It supports auto-scaling, multi-zones for isolation and more. In this talk, I will go through our data processing journey, and how Google Cloud Dataflow helps solve wide data processing patterns.

“Nobody lets me do anything around here!”, how many times have you heard this sentence? We all have great ideas, from integrating a new React library, to rewriting our entire codebase in Go. But the road to bring these ideas to fruition, is… well… not that simple. And sometimes even frustrating. In this talk I’ll share a few stories of success and failure in promoting some of my crazy ideas. From each story there are lessons and skills to be learned that helped me to make my ideas to reality. And finally, I’ll share how we took these lessons to create a scalable process to enable our developers to incubate and promote their ideas.

Diversity, and especially the involvement of more women in the workforce, should be viewed from a different perspective. I want to look at this issue from a purely utilitarian perspective: companies want to hire & retain the most talented developers out there. Obviously, many of them are women and we want to hire & retain them just the same. Addressing that challenge may require taking approaches different from the ones we’re used to. I will share the process we went through, which led to a wider look at our culture and the messages we convey outside, and even more within the organization. I will also share some practical ideas on how you can make a change in your organization.

In the micro-services world, we have the flexibility to choose different DB to every service we build, but how can we know what is the best fit to every use case? We understand that there is a major difference between SQL and NOSQL DB, but there are still so many types for both. How can we know which one we will use for Search, big data, reports, analytics, web application, API apps and more... I will share my experience while building different apps from scratch, and talk about the challenges that I had in choosing the right DB.

Just joined a company full of super-senior-10x-developers and you feel lost and scared? You want to boost up your career and become a better developer? Or maybe you just want to have more impact in your current role? The talk will focus on the state of mind and actions that can help you to maximize your impact, and improve your software skill level :) It is based on my own experience as a super fresh and inexperienced graduate joining a company where the concept junior developer didn't exist, to a meaningful team member, and later becoming a lead developer. The lecture will tackle a super important question: <b>How can you give and get the most value from your job?</b> come and find out.

Traditionally, a lot of companies rely on off-the-shelf data analytics platforms like Mixpanel for product analytics to understand each user’s journey. However, if your product becomes a success and your volume of events is getting high, these solutions may become somewhat expensive. In this talk, we are going to review one of our projects with Jelly Button; to design their own event-analytics solution based on Kubernetes and Apache Beam The results will save Jelly Button about a quarter of a million dollars each year. Together with Jelly Button’s team led by Meir Shitrit and Nir Shney-Dor, we have build a global, robust, and secure data pipeline solution.

In recent years, machine learning techniques such as deep neural networks have found uses in diverse fields where they have produced results comparable to and in some cases surpassing human experts. Machine learning requires large amount of data for its training as well as high-end GPUs and accelerators which enable parallel and efficient execution. But high capacity storage is not designed to deliver the throughput required by GPUs. This talk describes how we solved this mismatch and enabled IBM Deep Learning as a Service to take advantage of inexpensive and scalable object storage while keeping state of the art GPUs fully fed.

Every organization is constantly trying to improve its efficiency, through improving processes and decision-making, and more. In a tech company, there are a number of methods to increase performance while accelerating efficiency, and automating everything is just one. Hear how building a team designed for automation will drastically drive efficiency, performance, and team motivation.

My goal was to make an useful dashboard to monitor daily operations such as CI/CD processes or JIRA tickets, get information about server statuses in real-time. I will present an open-source dashboard framework and widgets a tweaks I have added to it and how I have integrated a Slackbot and different bot features into that. #slackbot #ruby #coffeescript #monitoring #raspberrypi

One of the first steps in (agile) development of a new product feature is getting a PoC up and running, before architecting a full solution. Building the initial infrastructure to support all the components is a complex task, especially when additional services such as databases are required. In this talk, I will demonstrate a concept we adopted when we first built what is now the heart of the PerimeterX. Running a full solution from the frontend to the application layer, message brokers, cache, and databases. All linked together with the ability to develop on each layer. I will also cover the road to production and which parts of this initial concept are still alive today in our service.

Most of the developers probably heard about Kali Linux, One of the best platform for security analysis. But how much developers know how to operate it? How to master it? In this talk, I will introduce Linux Kali from a developer side and NOT the security research side. It means that I will show how to use Linux Kali (without any need to download and install it) to pentest you own web applications. From how to install it to learn the basic tools. After this talk, you will be able to use Linux Kali everywhere to test your applications.

Diversity is more than a hype. It has been proven to generate innovation and productivity; it became one of the essential things millennials look for at companies and failing to manage it causes US companies to lose more than $64 billion a year. However, in most R&D departments, there’s still a struggle and difficulties in achieving diversity. This session will prove it’s not as hard as you think. With the right state of mind, a bit of guidance and a few tips we learned over the past two years - you’ll be on the right way.

Development on wearable devices always seemed fun. The chance to make physical impact, getting to know interesting new fields, and producing a tangible product, other than the virtual one in the software world. But what happens when you need to test augmented reality on a basketball court, but you're still in the office? When you can't to get concentrated enough to get the brain sensing headband running? On this talk we'll present all the pitfalls we encountered while developing on wearable devices

While finding good software engineers is hard, finding the right ones for your team is harder. As we grew our engineering teams, we found ourselves putting a lot of time and effort into not just the hiring of employees but also the fine-tuning of the hiring process itself. In this talk, I'm going to share with you how we use games as part of our interview process. What led us to use this technique, a few takeaways from running this experiment for the past year, how you can use it today and of course - a live demo where we defuse a bomb together

Over the last 14 years of my work as a developer, a manager and a mentor, I've seen that developers are constantly looking for ways to improve their productivity, yet constantly falling back to local maxima optimization. Overwhelmed by tasks, bugs, notifications and things you want to learn? Let me help you with the 5.1 methodology. I will give you 5 guidelines and 1 rule that that will make your work X10 times efficient and your life X2 calmer.

What does it mean to strive for ENGINEERING EXCELLENCE? As your engineering organization grows, you want to encourage teams to develop and improve their technical proficiency. Hyper-growth puts stress on your teams' ability to deliver kick-ass code consistently. To help them improve and grow, we built the LEVEL UP model to represent everything that's expected of an excellent engineering team. In this talk, I’ll review why we built this model, refined it and how we got teams to adopt it and the effects that it had on our department. I will also give you the tools to either use our model or fork your own specific one for your organization.

We all have that ideal world where we TDD-all-the-things and our code is at its highest quality. We know tests allow us to move faster, avoid regressions and make the world a better place. But writing tests is cumbersome. And tiring. And you hate it. It’s not that you don’t believe in code quality, it’s just that all that overhead all the time is really annoying. We’re just trying to move fast here, really. We have a product to build, you know. It doesn’t have to be that bad. In this talk, we’ll go over what makes writing tests so difficult, what’s the process of writing good tests effectively, and some low levels techniques that will rock your tests world (not really, but they’re useful).

Quantum computing takes a giant leap forward from today’s technology—one that will forever alter our economic, industrial, academic, and societal landscape. In just hours or days, a quantum computer can solve complex problems that would otherwise take billions of years for today’s computers to solve. Q# is a brand-new quantum-focused programming language with native type, operators, and other abstraction including interoperability with the Python programming language. In this session participants will learn about the upcoming quantum revolution and how to quantum teleport with Q# and python.

Building micro-services using Go and [gRPC](https://grpc.io) brings with it a lot perks, however testing gRPC API is not that trivial. Before calling any gRPC method one need to compile [Protobuf](https://developers.google.com/protocol-buffers) messages to your language of choice. Once compiled you are left with Stubs (clients) which you use to test different scenarios. Some of you are probably familiar with [Gatling](gatling.io) and using it to test your REST APIs. Out of the box, it supports only HTTP/1, but the core engine is actually __protocol agnostic__. In this session I will show how it's possible to test gRPC using our soon to be open sourced Gatling "plugin".

Lately I had the opportunity and pleasure to facilitate a process of designing cross-functional feature teams in a self-selection process with a company I worked with. Self-selection is a facilitated way to let people choose which team to work in. It is surprising how rare this practice is sometimes even considered eccentric while practically it is a simple and fast and produces such great results – well-formed teams with more involved and engaged people. In this talk I will share how to take a big group of engineers and let them build the teams by their own, the important role of the leaders in this process and how it impacts and set the stage for high performing teams

When working on data science projects we are often tempted to leave our code to rot in scattered notebooks or Python modules deep in repositories. However, even when you can’t openly release your code, breaking some important components into standalone Python packages can help with managing technical debt and code maintenance, facilitate in-house code reuse and repurposing, and make production-ising and deployment of code easier. In this talk I'll demonstrate how packaging your code can benefit both your colleagues and (present and future) you, and review the tools Python provides for building and managing these packages, both in-company and openly, sharing from my experience.

Variational autoencoders (VAE) are state-of-the-art generative models, allowing to build better language models with more coherent and diverse results. I will explain what are VAEs, and review recent papers applying them for continuous sentence representation (namely 1511.06349, 1702.02390). I will also discuss my recent research results on combining VAE's with sequence-to-sequence models and of course read some computer generated poetry.

How we got to building *fullstack teams* instead of bringing fullstack developers. High quality and velocity of releases are not an easy task while growing. How to manage parallel execution? What’s the best framework to manage the feature from the ideation phase to release? How to maintain the visibility? In our session we will talk about how we’ve increased our teams’ productivity. We will also discuss our adaptation of the squad model, bottom up continuous process building and decentralized decision making. This is our TeamLead *and* PM perspectives on exploring, experimenting and achieving a sustainable, high impact process flow.

What if someone told you it is forbidden to use logs anymore? Why do I need logs anyway? In this talk, I will revisit logging best practices. Why, when and how logging should be used. The talk is based on my blog post: [X tips (x>5) for Micro-Services Logging](https://www.outbrain.com/techblog/2018/05/micro-services-logging-tips/).

In the last decade, the centrality of front-end components vastly growing. Developing front-end in a large scale requires declarations and enforcement of principles and guidelines for keeping the code maintainable, extensible and stable. My talk main notion is to introduce the S.O.L.I.D principles within the context of front-end components. I will discuss the reasons for implementing the S.O.L.I.D principles in our renew web applications as a comparison to our starting point. I will suggest guidelines based on my interpretation of S.O.L.I.D in the front-end world. I will enrich the discussion by supplying various practical examples regarding the guidelines implementation.

Onboarding is the word that comes to mind when defining the first experience of a user in our product - mostly related to mobile apps and introduction of new features. But, how do we define an onboarding that truly serves the business goals while also delights the users? In my talk I will explain a better approach to onboarding, and how to define an efficient, unforgettable one.

In a micro services environment, it's common for every service to make remote calls to another services across the network. By design, remote calls can fail, or hang without a response until some timeout limit is reached which can lead to cascading failures across multiple systems. In this talk we are going to cover Outbrain's strategy of implementing circuit breakers and treat almost every micro service as optional, allowing us to run our system using hundreds of different micro services with 100% success

The Onion Router or Tor is one of the best tools for being anonymous on the web. In this lecture, I will talk about the methodology of Tor, how to operate it, common pitfalls and misconception. After that, I will show how to create hidden service in Tor that is also available in the clear web.

Having long ~1500 automated tests in Selenium is hard to maintain. We reached a point where automation was a big burden on our development: a team of automation developers triage every morning the failed tests from the day before -> create JIRA issues accordingly -> a triage from core developers "bisect" and find the accountable developer. After the last big refactor in our main SPA site, we realized that this can't go on and we have to make some changes. Now every release candidate commit has a quick response on the changes he made. This talk will be on our road to make this happen.

In this 5 min. session I will try to explain consensus in distributed systems and their necessity for cryptocurrency. then I will introduce few consensus algorithms such Proof of Work and Raft. By the end of this talk, hopefully, you will have a better idea why consensus algorithms are cool.

How to plan and execute a data migration when the migration needs complex calculations before inserting the new data (can’t be done with reasonable SQL). Will describe our latest attempt and all our mistakes which lead us to presume we will know how to do a complex data migration.

When your system is composed of many micro-services, testing becomes more challenging. The straight-forward approach for E2E testing no longer suffices and for integration tests it doesn’t even exist. A better way to test in this kind of an environment would be to work with a test kit of the micro-service you are interacting with. You will learn how to create a test-kit that covers your micro-service. Testing this way will grant you a much higher level of confidence, and will portray a more accurate picture of your assumptions vs. reality. Overall it will make any integration between micro-services easier, thus benefit your colleagues and make your company progress faster.

Deployment to Production can be scary , in this session I will present an open source solution and a study case on a previous project of mine with Rundeck Orchestrator, which provide a pipeline visualisation of the whole deploy processes. the issues that came up a long the way , the deploy processes itself and report on each deploy.

Feature flags have been trending in the last few years, and for good reason. In an agile environment we want to move fast, experiment a lot, and still maintain a quality product. By using feature flags correctly, we can leverage techniques such as A/B testing, canary releases, feature gating, kill switches, and more to accomplish these goals. Feature management solutions have been developed and used at scale by leading tech companies, but unfortunately almost none of them are publicly available. In this talk, I'll share some of our experience with feature flags and showcase Tweek - our very own open source solution that can be used anywhere by anyone. (https://github.com/soluto/tweek)

When you are writing code, you have a very clear target: that the code will run and that the output will be as expected. But have you ever stopped and thought about the language in which you are writing? The lecture will deal with topics that programmers usually don't talk about: Evaluation order, Variables scoping, what happens behind the scenes, and in general - the meaning of every line of the code. The purpose of the lecture is to give you a deeper understanding of the Python programming language through simple examples.

In Deep Learning we try to learn the signal found in the data. Some of the features can be the IDs of real world objects (word / item / category). But what happens when we get in inference time new objects never seen before? How can we prepare ourselves in advance so we can still make sense out of the input? In this talk you'll understand how to handle OOV (Out Of Vocabulary), specifically in the world of recommendation systems where new items arrive on a daily basis.

One DB to rule them all? Hardly. Typical applications start their life with one DB, usually the one most fashionable, reliable, well-documented, referenced-on-google, or all of the above. Soon enough you find out not only that that DB you chose early on is actually wrong for you, but that it’s really hard to get rid of. In this talk you’ll see how in under two years, our application turned from single-DB, small & tidy, into a monster running four+ databases (on a good day), while testing and abandoning more than a few others on the way. I’ll discuss lessons learned the hard way on the process - about choosing a database, writing good code, making good products, and life in general.

REST is commonly used and considered as the `usual suspect` to solve any inter-process communication. RPC, data dump, message notifications, actors model, are all valid ways to communicate between distributed systems. In this talk, I will explore the different approaches and technologies in order to help you pick the right architecture for your domain.

MVP is the Lean way to iterate solutions that will really solve our user’s problems. However, quite often we find ourselves investing too much time and effort in the development of the MVP. Precious time that sometimes goes to waste. There are different techniques to minimize the required effort of the MVP like “Fake Door”, “Concierge MVP” and others that allow you to get user’s verification and invest as little as possible in the development. In this talk, I want to share examples from both personal and industry experience. The audience will get practical tools and methods to minimize their MVP’s that they can practice in their company or startup.

The code review process can be long and frustrating. When done on a daily basis, we might take it in the wrong way and think of it as an evaluation on ourselves (as developers) and not on our code quality/correctness. In this talk, I’ll share what I’ve learned from CRs in my projects, points to take into consideration and mainly - to not be afraid of it :)

Building a flexible, scalable, real-time data architecture for the enterprise is no simple matter. Rarely does one single technology suit for all requirements, and frequently many different teams are involved which drives solutions with varying levels of [dis-]integration. Apache Kafka is the enabling platform that supports the real-time, high performance, scalable integration of data throughout the enterprise, whilst also providing the messaging capabilities to drive applications directly. This talk will discuss the role and benefits of Kafka in a data architecture, and several patterns used to address challenges that organisations face with managing their flows and availability of data.

Keeping up with the technological breakthrough happening everyday is a challenging task. It's incredible to see how the modern ideas for solving current challenges (scalability, concurrency, reliability) where precisely defined by a language that is rarely used, Erlang. It's amazing to see how a Brazilian guy leveraged an incredible architecture with a not so cool syntax and transformed it in a growing and beautiful open-source community.

Vector graphics is in fact the best way to provide great visualization and interaction combined. It exist on all platforms in some way or form, so it's just natural to use it in React Native. In this talk, I'll show you how I integrated the use of SVG with the opinionated component and state system of React, but in the same time keeping things highly performant when interacting with the UI thread - a topic a lot of developers are struggling with.

Where do engineers go when the management path is not an option? Do I have to manage people in order to move forward with my career? And if I don't like that, should I quit and start from scratch? Don't worry - there is an alternative, and it's called being an "individual contributor." In this session, I’ll describe what is this Individual Contributor path and how to grow in this track (as I see it).

A conflict between containers and functions? We’ve been shifted to containers and now all vendors tell us to throw it away and unpack our code? Maybe we can combine the two. In this talk, I will review the different possibilities of shipping Containers as Functions as oppose to FaaS Vendors' standard Functions implementations. I'll actually demonstrate how to write C code and run it as a Function! Moreover, I will talk about the importance of Multi-Cloud & Functions, how we can save a ton of money, improve our service's SLA & leverage the "cloud" it was meant to be.

As Wix grew exponentially with more than 600 micro-services, it became obvious our previous CI solution for jvm/scala code has been slowing us down. A decision was made to switch to Google's new yet immature open source Bazel build tool and cloud platform. In this talk I will share our story with you: why we chose this technology and what we did to adopt it and enhance it to suit our performance and other needs. You will learn some key guidelines on how to make sure that a migration to a new yet immature system succeeds. These guidelines include: “Identify crucial missing features”, “Establish a good working relationship with the new system provider” and many more.

There are many non-government organizations (NGO) in Israel that work for the weak parts in our society. Most NGOs are relatively small and don't have much money. They need different types of software for their work with their "customers". MicroFocus have special volunteering activity in which software engineers volunteer to write software for such NGOs. In this lecture I will present what was done and what is still needed. Examples to such projects: - iOS application for "prize for life" NGO that work for ALS patients. - Android application for "machshava tova" NGO that work for empowering children. - Web site for "Nitzav Refael" NGO that provide food for people who need help.

As developers we aspire to write the perfect projects: Have a proper design, write elegant code , use the best technology etc. And then life get's in the way: strict deadlines from management, old projects that aren't written properly, technical limitation of projects. In this talk I will give a Critical view of the relationship betweeen product managers / Management and developers and try and give some useful advice on how to bridge that gap. Share some ideas of what to compromise on and what not, how to plan the project so we can eventually get closer to our dream project and not end up with a Meh project .

As software developers, we strive to improve our code, our tools, our work processes, and ourselves. But when was the last time you gave thought to your workspace? Open-plan offices have a been our de-facto work space layout since forever, but they always felt wrong to me. I set out to explore, read research, interviewed dozens of companies and found out the open-plan office really is killing us all. This talk has been in the making for the better part of a decade. It will be a whirl-wind tour of open-plan’s history, why it’s so ubiquitous, the research made into it, and offer ways to either change it or, if you can’t, make the best of it.

During the Cold War, the CIA knew how to expose Russian spies disguised as American citizens with 100% certainty. They used only a piece of paper and a few questions. How did they do that? Hacking your mind is easier than you think. Let’s explore how these mental hacks affect the code we all read and write. We’ll take a stroll through the world of cognitive psychology, and shed some light on some of our industry’s best and worst practices. We’ll have a few interactive examples of our mind’s limitations, examine how these limitations manifest themselves in real code samples and engineering practices, and take away scientifically backed techniques on how to write better code.

In 2008 the market collapsed worldwide and our one-year-old infant startup was close to joining the sad statistics. We almost run out of our seed funding and our product results were poor. After cutting down salaries we were able to get some additional funding to run the company for few more months. We understood that things need to change in how we build our product and how we validate our offering. 6 years later, we sold Check to Intuit for $360M. We are now running Next Insurance on the same concepts with exceptional results. In this talk I’ll explore how we put lean startup concepts hard at work and how we’ve been able to take our product into massive acceptance by millions of users.

As event sourced micro-services become one of the most popular architectures to build a distributed, data consistent, large scale systems, many companies find themselves facing the ultimate equation of System Efficiency vs Cost. Being ready for large scale data inflow at any given time while keeping the compute cost at its lowest is a challenge we have faced at Trax as well. In this talk we will present our dedicated solution using some of the basic APIs given by all cloud provider. We have ended the journey by both reducing the delays in the system to minimum and by saving ~65% of the compute cost.

Telling a cat from a bird? that's easy, most infants can do that. But how about learning to paint a black and white photo with real color? It's time for your models to grow up. We find that transfer learning from different datasets and tasks saves a lot of time and money when labels are scarce and data is limited. In this lecture, I review self-supervised methods that are used to pretrain models on unlabeled data. Methods from the fields of Vision, Audio and NLP will be refined so they are applicable with other domains and effective on your data.

Open source software is one of the biggest game-changers in our world. It has a lot of benefits, the most critical one being minimizing the time to market. But it’s not a free meal, and you should take care of many aspects when choosing one: * Bug fixes (“wait a minute, I need to know $lang?!”) * Security (“who the f*** gave full access to my credentials dir”) * Stability in different bad cases (“why did jobs execute dozens of times when workers lost connection”) Those can catch you one day in a very unpleasant situation. In this talk I will take you on a tour of some key indicators that you need to bear in mind when choosing an open-source library or component.

As microservices gain popularity, Kubernetes has become the #1 platform that enables organization to deploy their microservices with ease. In the Kubernetes world, a single application can have thousands of instances that are ever changing since Kubernetes spins instances up and down by itself. This complex & dynamic world can be very hard to manage, secure and debug. In order to solve this, a new concept was created- the Service Mesh. I will present a service mesh solution, Istio, and how it helped my company to overcome the challenges the new world of micro services presents and deploy our solution in as a secured and properly managed solution.

Imagine a world where shipping logs is as easy as writing them to stdout. Look around you, that’s the world we’re living in right now! Fluentd is a log aggregator that allows developers to just write logs to a stream and never worry about them again. Fluentd then picks up those logs and can ship them to various endpoints. It can also filter, aggregate, transform and do so many fancy tricks to make monitoring your systems easier.

A git branch containing many merge commits, where long strands of commits evolve in parallel, makes the history much less useful for the future of the project. Such branches, whose graph looks like a "Menorah" (חנוכיה) are best avoided, and it is recommended to rebase before pushing to create a more-or-less linear history of the project.

So you’re on a software team, and that team has a manager you answer to. Everything is nice and simple, but as the team grows and the product evolves, the limits of this model become readily apparent. That’s when many teams, maybe even yours, introduce a role of “technical lead”. People, however, are anything but simple. When there are no clear boundaries, you’re bound to run into issues with the human element. In this talk we’ll share our experience as tech lead and engineering manager in our own group at WeWork, highlight some of the mistakes we’ve made on the way there, and share lessons and best practices learned to implement this model in practice.

On our path to professional mastery, there is no substitute for good mentoring, the form of teaching that occurs in a one on one, Master-Apprentice setting. Often, though, and despite our best intentions as mentors, we fail at it miserably - leaving everyone involved frustrated and unmotivated to either teach or learn. Can we do mentoring better? I believe we can. But only if we improve our understanding of the inherent challenges that derive from sharing knowledge across human beings. In this talk we’ll shortly discuss some core aspects of the problem, we’ll dive into a few characteristics of the problem, and in the end, we will come with a few remedies as well.

Golden rules are abundant in software engineering. You should have a simple micro-services design, do TDD while pairing, deploy 42 times an hour with 4 variants of A/B tests, and always eat your vegetables. However, real life pragmatic considerations will lead every organization to make compromises. Whether you’re a startup going quick and dirty in order to survive or an established company that maintains some older code, you may get to a point where you must improve your testing or even start it from scratch, while moving forward and adding features. In this session I will explain how it can be achieved, sharing hard learnt lessons on practical automatic testing strategies while on the run.

Run your dev server, open http://localhost:8080, and voila - your web app is running in front of your eyes. But what about those who can't see? How can we build an experience that is also relevant for sight-challenged people? In this session, we will do it differently. We are going to code without actually using browser - just a screen reader. What does the feel like? Can we make it better by adding some accessibility love to our app? Let's figure it out together!

The session is aimed for those who have knowledge (at least basic) of the SOLID design principles. While SOLID is a catchy name, it is still not always intuitive to understand - and more than that, to teach your team - the ideas of those principles and what made them be chosen over others. I had the very same issue when I had to teach my students, and while I started explaining that, I have found a great graphic representation of those principle that makes those five principles as intuitive as arrows on a whiteboard.

R&D organization as well as חברת חשמל, and רכבת ישראל are all monopolies. Monopoly, just like money, discount, debt, interest, regulation, incentives, and auctions are terms taken from the field of economic and are relevant for software development. In this talk, I will give examples how I used economics concepts and apply them to software development. This how I managed to take better decisions, motivate my team, and to improve code quality,

I’m sorry to say it, but you fear your code. Once written, once in production, you are afraid of changing it. When there’s a bug, you prefer to fix it using that messy, yet surgical, hack, rather than the more logical refactoring that leaves your code better. Admit it! You fear your code. But there's a way out: just write tests. Writing tests is impossible! It makes my productivity tank! My boss doesn’t leave me any time for writing tests! These are all excuses for not writing tests. I will show you techniques that will force you to write those tests, and I will show you how they help you sleep better at night, make you more productive, and make you a much better developer.

Engineering organizations, which are moving to modern microservice architectures, realize that the majority of operational problems that arise when moving to a distributed architecture are in areas: networking and observability. As per-process logging and metric monitoring cannot reconstruct the elaborate journeys that transactions take as they propagate across a distributed system, there is a need to take a different approach. In this session, I will present OpenTracing, an open distributed tracing standard, and demonstrate how it helps Dev/DevOps engineers conducting service dependency analysis and investigating latency problems in microservice architectures.

Classically-trained software engineers are used to clear problem statements and success criteria. Need a mobile front-end for your blog? Sure! Support instant messaging for a million concurrent users? No problem! Unfortunately, modern software poses challenges that we have a hard time with: those with no clear criteria for correctness and no easy way to measure performance. Your blog platform better have a spam filter, your chat has to have search; neither is trivial nor obvious. In this talk I'll share my experiences of learning to deal with non-deterministic problems, what made the process easier for me and what I've learned along the way. With any luck, you'll have an easier time of it!

In this talk we will discuss why the famous "Shape" and "Student inherits Peron" examples, shown in a lot of forums, don't match at all the OOP principles and are in fact bad examples, and even how most Design Patterns lessons didn't really created better object oriented programmers. Instead, we will show how we can build a real OOP thinking and upgrade our design skills. We will use real world examples in C++/java/c#.

Cloud is the de-facto standard for data driven applications. However, cloud provider services tend to be slow, expensive and come with potential lock-ins. With emerging open-source cloud-native orchestration tools like Kubernetes, open source data stores and serverless platforms you can build your own multi tenancy cloud data service, save costs and gain performance and portability. The session will describe how you can build an equivalent set of AWS data services with cloud agnostic tools and achieve an Amazon like experience. Present a variety of analytics tools and explain how to use Kubernetes, as well as how to handle . A lesson learned through the suffering of others.

כולנו זוכרים את בינבה..אי אפשר לתפוס את בינבה החכמה, ולכולנו יש את הרגעים האלו שאנחנו מאחרים בטירוף ופתאום יש לנו עיכוב בווייז כשהוא מגלה רגע מאוחר מדיי שיש פקק או תאונה בדיוק בכיוון שאנחנו נוסעים. מה אם באמצעות מכוניות מחוברות ודברים שנראו לנו בילדות כמדע בדיוני נוכל לגלות את הדברים האלה בזמן אמת? באמצעות האנשים שנוסעים רגע מלפנינו ויכולים לתת לנו את המידע הזה לפני שזה נאגר ונעבד מספיק דאטא בשרתים של ווייז שכנראה יעדכן אותך לפעמים כמה רגעים מאוחר מדיי. אז הנה זה כבר קורה. אנחנו נדגים איך ניתן לבנות מערכת קצה (edge) אינטלגנטית שמתעדכנת בזמן אמת - המתבססת על רכיבים שהם open source. באמצעות טכנולוגיות כמו Kubernetes, (FaaS), Akraino עם ליבת תזמור (orchestration) מתוחכמת, העתיד כבר כאן.

Micro-Frontends are gaining a lot of traction these days as the "silver bullet" solution to the Monolith project problem and you might find yourself asking “am i missing out on something important?” or “what does it even mean?” In this talk, i will show you the journey we went through when we “accidentally” found ourselves in this type of architecture, how it helped us to achieve our goals, when it made our life miserable and finally will try to answer the ultimate question “is it really a silver bullet?”

I started writing code at the age of 14. After a non-technology army service, going back to coding seems like the logical path. With the years I evolved as a developer and become a dev manager, but I felt I want to explore other areas as well. I found myself as a product manager and from there to product marketing and VP marketing today. Along the way, I kept my technical knowledge and I adopted methods how to be a marketer that can code, and how to leverage R&D concepts into marketing teams (AKA Agile Marketing). After 20 years in our industry, I'll share my personal story of career growth within the high-tech scenery, and I hope it will assist others when in doubts.

Whether we like to admit it or not, we've all borrowed code from stackoverflow at one time in our lives. Many do it more often than they care to admit. If a vulnerability exists in a stackoverflow code snippet, it's easy for it to go viral in even the most widely used frameworks and libraries. In this talk I’ll share the findings of the research we did resulting in several wide reaching vulnerabilities affecting different ecosystems (Java, Node.js, Go, Ruby, .NET) and many of their applications and libraries. We'll look through the technical details of the vulnerabilities, and what can we do to avoid them.

Sometimes we run too quickly to code while skipping a few steps along the way. Using an effective work process like it's second nature makes all the difference, and will help you take the next step in your career. Taking the time to plan, design, and build a work plan with clear milestones, short sub-tasks and time estimates is half the way to a successful project. Using a shared task manager as your ally on a daily basis helps you focus, provides transparency into your progress and better understanding of your priorities and technical considerations. Using examples, I will describe how an effective work process can make all the difference, and take you to the next level.

It’s almost midnight. Me and my daughter are looking for jumpers, matrices and resistors. There is a bug in the game we’re building, and it doesn’t seem as if we are going to bed anytime soon. Teaching kids recursion and data structures didn’t create the thrill I thought it would. But building games does! My daughter Roni and I will talk about introducing kids to the world of programing, 3D printing, Scratch, Arduino, Ali Express orders and hot glue. We’ll cover the existing tools from which kids can learn how to code, at what age should they start, and which projects to choose. And why girls at school are anxious about coding? Is it a boy’s club already before high-school? 

I will give a short intro to SQream GPU SQL database, it's advantages for Big Data (currently querying 300 TB of raw data in production) and real-world use cases. I will give a demo of running SQreamDB on Docker using the Nvidia-Docker framework, integrated with Kafka-Connect (running on Docker) for ingesting data.

Building a team is not an easy task, also it’s not a magic. Being precise is the one of the greatest challenge in the journey that each group must go through. You can think about building a team as a sport team training. Indeed, there is much to be learned as engineering practices. The team must acquire a few soft skills, the most important one, is the communication skill.In this talk, I will show you how to grow your team’s soft skills through an Agile Game.As a manager you will be able to integrate the game into your everyday agile process.

After running developer communities over the past 3 years, meeting a lot of great people and learning a lot of things about the Israeli Hi-Tech ecosystem, I’ll share all that I’ve learned about what it actually means to create what is called a “Community”. The value that you as a community lead can give to the people in it and the things that you can gain as a geek out of it. You’ll be surprised to learn how easy and hard it can be at the same time. I’ll tell about the steps that I’ve taken in this journey, what in my opinion might kill the concept of “Developer Community”, by the end of the talk you'll have as many tools as possible for you to be able to create a community of your own.

You know how user profiles contain all the info you need from day 1, including future attributes you never envisioned needing? Neither do I. User profiles are a crucial building block for any personalized recommendation algorithm. Especially when you're the scale of Outbrain, with over 1 billion named users. But the brilliant architecture that we had for years evolved into a brilliant, steaming mess that slowed us down to a screeching halt. That is, until we bit the bullet and redesigned this core component in our architecture stack. In this talk we'll show you how to create AB-tesable profiles, filter signal from noise and prevent data from turning you into a cat lady.

Out of vocabulary modeling is a very common technique to handle non frequent entities in a training dataset. The usual approach in deep learning is to assign OOV embedding that is shared between all the non-frequent entities. Sharing one vector representation among very different entities is inefficient. In this lecture i will show how to create more classes of OOV and how to assign each OOV entity to a different cluster by learning to classify rare data points to cluster.

In the next 5 years there are expected to be a billion new internet users, that means a billion people that are going to gain access to the internet for the first time in their life - most of them will be coming from countries like Nigeria, Indonesia, India, etc. We're going to talk about who those people are, how they are different from us, and what we need to do in order to provide them with an ideal experience.

In this talk we'll take a hard look at one of the most commonly used, and at least as commonly misunderstood, elements in software engineering: time. Time is so fundamental to the way humans experience reality that we don't normally give it a second thought, but it's just as fundamental to software systems. Without a correct model for working with time BAD THINGS HAPPEN: data is persisted out of order, exceptions occur where they shouldn't be possible, and production systems blow up. We'll cover the various common representations of time, acknowledge their caveats and deficiencies, and hopefully learn a few new tools and practices along the way.

To defend against attacks, think like a hacker. But does that mean you need to be a DevOps expert? Security researchers today need to discover new attack techniques. However, much of their focus is diverged to backend coding. We share how to build an infrastructure for researchers that allows them concentrate on business logic and writing hacker “tasks”. Using Docker and Kubernetes on Google Cloud, these tasks can then be performed in parallel and without a lot of DevOps hassle. Our technique removes two common barriers: first, long and risky deployment processes and second, low transparency within the production system. Promise to share the stupid things too.

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.

How to run multiple and instant daily deployments to production by the quality and development team members I'll introduce one of the biggest game-changers in LivePerson, which is moving production engineers today from gatekeepers to enables, by handing over the responsibility of the CI/CD to the developers themselves. This requires providing developers with creative tools that can safely and easily deploy to production or rollback. In this talk I'll demonstrate an end-to-end solution based on Jenkins and Groovy developments, using Jenkins DSL and pipelines. This process has been developed internally and increased the accountability and the commitment by the team members.

One of the common ways in physics to predict properties of materials is to make a statistical analysis of many atomic configurations and forces. The forces could be predicted by solving a quantum mechanical differential equation with a huge amount of variables. Typically one would need millions of such calculations to predict such properties as diffusion constant, melting point, or battery performance. In our work, we suggested a direct and local DL model for atomic forces. We analyze the model's performance as a function of the input and show that one can ascertain physical attributes of the system from the analysis of the DL model's behavior.

Images and video are core components of all mobile apps, and as the next billion mobile users come online, they will mostly interact through images, voice, and video-based applications. These applications need to operate globally and provide a great user experience over any network. In this talk, we will identify the problems developers face around image delivery and mobile performance. We will learn how to create a high-quality mobile experience, even for users in low bandwidth areas and on devices with modest processing and memory capabilities. At the end of the session, you will learn how to improve your mobile users' experience by changing just one line of code.

Part time work is great. It enables people to work while spending more time on their studies, family or startup. But it also comes with challenges. How do you manage your tasks and time when you're only working 1, 2 or 3 days a week? How can you make the best of your time at the office? If you have a part-time team member, how can you benefit from their expertise, without getting stuck waiting for their input? Also, managing yourself as a part time worker is hard, managing a part time worker is just as hard. How should your management style and expectations change to enable them to work efficiently? In this talk I'll share my experience, and hopefully some answers.

Overt the past months I've been leading the development of the new Selenium IDE, https://github.com/SeleniumHQ/selenium-ide. A browser extension that records user interaction, and is able to then play it back. This project is a resurrection of the old IDE which is no longer maintained, and was technologically eclipsed. I will talk about how we took an obsolete project, with over a million downloads in it's lifetime, and brought it back to life, with modern technology and toolchains.

When was the last time you wrote an algorithm to plan your diet? As programmers we do amazing things in our everyday job, but rarely do we use our knowledge at home. In this talk I will introduce genetic algorithms and share how I coded a genetic algorithm from scratch and used it to generate my weekly schedule and to create a smart diet planer. We will go through the different stages of the algorithm and understand how they affect the algorithm’s solutions. Let me show you a different side of genetic algorithms and you will discover a new way to solve your everyday problems. This sessions is presented in English.

A fully implemented SDLC program is often represented as heavy, time-consuming and not suitable to Agile development methodology. We’d like to break the myth and show how a very comprehensive security program, managed by a dedicated security office and development Project Manager, can be successfully integrated in agile development project on a real case example. We’ll shortly describe the main challenges, the techniques and the procedures helping to overcome the challenges. We’ll present the Security Lifecycle Management Framework developed and used by us in the last 3 years, and describe how it was integrated into development of new SaaS based fully agile developed product.

Building a microservice based product seems like the common way to go, but it comes with a price. Each microservice has baggage, like CPU/memory footprint, which can be painful for Python based microservices. So how can we reduce overheads without giving up on microservices? I’ll present a solution which bunches Python microservices in a configurable way during runtime, allowing freedom in deployment to balance between encapsulation and reduction of a system’s footprint. I’ll show how my team created this mechanism, decoupled from everyday development of our microservices logic and share how we reduced the microservice count down from ~50 to ~10 per node, without compromising functionality.

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? In this talk I will share my journey and insights, on the what and how of being a modern Software Architect. This is a summary of my insights after making the shift from a manager into an architect and back again into management. This trip turned to be much more challenging and exciting than I ever thought it would be. I found myself spending more time at figuring out what is it that I should be doing, than on how things should be done.

It is a common illusion that Product Managers in the current reality, can continue working to define products, without thinking about security aspects, and that this can be done at a much later stage in the product lifecycle. How can we turn the Product Manager to be a real security ambassador? We’d like to show how a very comprehensive security program, managed by a dedicated security office in cooperation with a professional Product manager, can raise the “security organizational conscience” and can successfully integrate in security aspects in every product, with emphasis on agile development lifecycle!

Developers in agile teams face the challenge of developing complex software under tight timelines and continuously changing scope. The team must be innovative and quickly develop new functionality at high quality. Obviously – the way the team writes code is a key factor of a successful project. Implementing agile means many things, it means learning and understanding the set of principles and values and acting accordingly, it means adopting work methodologies such as Scrum / Kan-ban and having the ceremonies.. but wait, what about the code..? in the session, We'll try to take agile to the next level and straight into the "production floor".

At Satellogic we are building an open source project called Telluric. We use this project to do our own Geo-Spatial calculation. The main idea is to combine the following GIS libraries: GDAL, rasterio, fiona and shapely to create a easy to use and powerful interface to Geographically located Rasters and Vectors. You can use this library on a Jupyter notebook or on a dask cluster. https://github.com/satellogic/telluric * Satellogic is an international company, so not only Israelis are working on this project.

Recommender systems need to optimize a delicate balance between exploring new recommendations and exploiting informative ones. Up until this point recommender systems employed mostly bayesian prediction algorithms and utilized the inherent measures of uncertainty to optimize the crucial exploration/exploitation balance. While DNNs obtain state of the art results, they present specific challenges for recommender systems due to their lack of standardized uncertainty measures needed for most exploration strategies. In this talk I’ll cover how we overcome this challenge at Taboola and how we use uncertainty measures to our advantage when serving content recommendations billions of times a day.

DR drill always starts with a "war room" all the engineers gather in one room, get into the “DR channel in Slack, open a huge Excel and start following the procedure step by step David stops the “BE” service, Danit failsover the database, Dafna changes the app configuration. Kriss the DR “M.C” write everything on a whiteboard and so on to all services... Or otherwise: A developer go into hipchat, types “mastermove failover from NY to LA” and we're done. All systems moved to LA. In outbrain we are building a complete automation of the DR process, and we are happy to share it with you.

From the ghosts of Pacman to the hilarious antics of The Sims, AI has always been a key ingredient in fun, immersive video games. But most game AI is actually quite "dumb", acting based on simple rules and relying on the players to perceive it as more intelligent than it is. Imagination plays a key role in the experience. However, with the recent advancements in Machine Learning technologies, and with hardware finally powerful enough, games are beginning to make use of advanced and complex AI, opening up a world of possibilities.

In 2015, after about 10 years of managing, I decided to stop. Letting go of the managerial position is hard, sometimes it feels wrong, but I found it liberating. Being able to lead without authority seems much harder than being the boss. However, the challenge is both motivating as well as rewarding. And the biggest surprise is that letting go of direct subordinates allows you to influence much more people. WIIFM - not everyone can or should be a manager. There are other ways to influence and do more.

At Facebook Connectivity, we strive to move fast while ideally having a shared, robust mobile infrastructure that encourages reusable code. For our latest mobile challenge, we selected React Native over classic Native development. React Native's most common pro is that it enables shared code between web and mobile. Most people think that comes at a cost of lost functionality on the mobile side. This talk will dive deep into "bridging" the gap between React Native and the Android Operating System by discussing the React Native Bridge, Native Modules and Event Emission. At the end of this talk, we will know how to fully utilise React Native without compromising on app functionality.

When using Docker for production use cases, run and build commands can get unwieldly. Most of us use Crane or Docker Compose for management, but struggle with additional fat BL wrappers. Developers need to define images' build and run recipes in a more dynamic way then a YAML file. In other words, "separation between code and configuration" just went out the window. Meet Manof - the Jewish Crane. It's a standalone async Docker wrapper, which allows you to declare image setups via a Python module. In this session, participants will learn how to run Docker more efficiently while still having the Docker "definition logic" in one canonical and useful form for all repos and projects.

At CyberArk we're in the process of migrating our existing .Net/C++ monoliths to microservices. In this talk you'll see how .Net core can be used to iteratively migrate from a .Net monolith to .Net core microservices, starting from extracting code to a cross platform library and on to a full service running in a linux container.

We have an idea for a product but that just 20% - now it's time to make it a real live product and get users. This can take a while... We will talk about how to start planning and creating your product from concept to release and get it ready for our customers. So, what is the right way to get to your effective MVP and take it to the next level.

Developers go to asynchronous programming because it can increase application performance and responsiveness. However, using Python poses challenges as it involves dealing with Twisted, gevent or Tornado - each powered by a different kind of unholy wizardry. Python 3.4's asyncio finally changes that by offering a native Pythonic way to solve the complexity. This talk will cover the pros and cons of asyncio’s event loops compared to threads and processes, both in performance and maintainability aspects. We’ll also go over asyncio syntax, as well as cover the main concepts behind writing asyncio applications, common pitfalls and best practices.

The tech world is obsessed with performance, and for a reason: we constantly strive to give better experience to our users. In my talk, I will explain **why method-level profiling in production is important** and why we, at Riskified, decided to develop **Timeasure**, a Ruby library dedicated to this purpose. I will demonstrate how **exceptional aspects of the Object Model in Ruby** helped me design a **unique, pleasure-to-work-with interface** and how we managed to **reduce our main transaction's runtime in more than 500%** by using its outcome. **No experience in Ruby is required**, however I do assume general familiarity with the Object Oriented paradigm.

Feedback is critical to the growth of every part of the organization, be it yourself, your team or the organization itself. But yet, many workplaces fail to cultivate feedback into their culture. Working in such an environment can be a diminishing experience that may hurt our sense of purpose, motivation, and ability to grow. In this talk, I will define what is feedback, what makes it good, and why so many of us fail to give it. I will show how ways to find feedback even when the environment does not offer you any, be it your manager, your peers or anyone else within your organization. There is no such thing as "no feedback" - feedback is always around us, we just need to learn to see it.

Ceph is a very poplar open source software defined storage. It is distributed, highly available and designed for large scale. It provides block, object and file system interfaces. In this talk we will learn about Ceph and its architecture. Ceph has an Israeli user base and an engineering team at Red Hat Israel.

This talk revisits dependency injection, and attempts to answer a question honestly while pointing out and acknowledging the biases at play: "is dependency injection a good thing?" Dependency injection has fast established itself as a major design pattern in modern software. No longer the province of server-side and enterprise software, it is now a fundamental component of frameworks from Spring to Angular.js. With such widespread success, the time is ripe to take a fresh look at dependency injection if we are to understand it better. After all, DI is instrumental in building large systems that are loosely coupled, and it cleanly separates your tests from implementation... or does it?

More and more companies are using deep-learning based models. However, periodically updating products with such models is challenging due to large datasets and long training procedures. Face2Gene, FDNA's community-driven platform, is used to aid in the identification of rare diseases. With the constantly growing database, periodic system updates are essential. To enable that, we developed a unified system of data management and a scalable infrastructure to prepare the data and parallelly train and evaluate dozens of models at scale. The result is a production ready system. In this talk we will describe our system in detail, discuss the design challenges, and share best practices learned.

Engineering organizations, which are moving to modern microservice architectures, realize that the majority of operational problems that arise when moving to a distributed architecture are in areas: networking and observability. As per-process logging and metric monitoring cannot reconstruct the elaborate journeys that transactions take as they propagate across a distributed system, there is a need to take a different approach. In this session, I will present OpenTracing, an open distributed tracing standard, and demonstrate how it helps Dev/DevOps engineers conducting service dependency analysis and investigating latency problems in microservice architectures.

We are agile and effective @work but not @home. Using agile methodology @home allows us to optimize our expenses for our needs. Following agile also modifies our home to serve us and not vise versa. The lecture will be followed with examples from agile family home. Auditory will learn that applying a methodology from one area to another may benefit them in many ways. Open your mind principle - that's what makes us better and this talk is about it.

Progressive Web Apps are changing the way we think about websites and blurring the lines between Native apps and websites. PWAs enable websites to add features we previously could only use in mobile such as: * Push notifications * Full Screen * Offline working * Splash screen, to give an app like feel * App Icon on the home screen In this talk, we'll walk through all the game-changing features PWA offers by building our own PWA. The goal is to walk away with an understanding of the powerful features PWA's offer. Additionally, we will see firsthand how to convert a site into a PWA that’s just like a native app, but without the excessive file size or the lengthy install process!

Employees quit. Leaving is hard, but it is 10x harder for a manager to leave his people behind. There is almost no record of what should a manager do when he decides to quit. I don't believe that a manager can simply leave. He is responsible for his people and for many aspects of the company. His departure should be as smooth as possible. I wanted to leave my job in a way that doesn't hurt the company and the people, at least to minimize the effect to a minimum. In this session, I want to share my personal experience and the hard time of a manager who leads people and still chooses to leave. I want to share the path I’ve taken to make sure that my departure will be as smooth as possible.

Redux is awesome and is used in countless projects. However, using Redux does mean that there is a lot of boilerplate. Enter Redux Cornell. Named after the legendary singer Chris Cornell, Redux Cornell aims to remove most of the boilerplate which comes with using Redux, yet allows you to completely customize it. The library brings the concept of 'convention over configuration' into the JS world to help reduce boiler plate.

Let's be honest. Most of us still have huge amounts of legacy code we try to ignore. Probably a Monolith we can't get rid of. Code we fear changing either because we're afraid of regressions or because we don't want our name to appear in the next annotate. In this talk I'll present useful techniques for safely refactoring legacy code. These tools will help you refactor pieces of your Monolith into something you can proudly own, and if extracting to a micro-service is what you're aiming for (don't we all?), it'll help you make a smooth transition.

Klarna is "like Paypal, but in Europe, stronger on consumer, (probably) breaks more things, has too many official programming languages to count, and is allowed to be on the cloud. It's a tech jungle.". We had to introduce data driven decisions into an engineering process on a micro-service architecture layout. An experimentation platform that can work on N different languages (Java, Erlang and Haskell just to mention a few), has a <1ms overhead per call, no SPOF, extremely resilient, deployed on backends and frontends, had to be invented and then be built. By one person. This is a story about how I built it, and survived.

Today I'm working on an existing product. I'm working a lot about how to make the product "smart" - how to get data about the clients usage and get conclusion about it, and how to present it to the relevant users in a way it would be usefull gor them. I would like to share my experience and my reaserch in this field, as a programmer who do that for the first time in a new company. I would like to inspire other developer to do the same in their team.

As great products are being built more and more ideas are coming everywhere. Identifying and eliminating the bad ideas is easy but most decisions are not. They require you to understand them and replay “This is a really great idea, I can see why it was asked, however, this is what we're focusing on and building"

They are back! After the viral success of last year's interview song (https://www.youtube.com/watch?v=lUubm2B4VIU), Iftach & Yoni return with an epic ballad about an epic programmer. This will be a satirical song, mocking some of the unique patterns of modern software development in Israeli hi-tech. There will be laughter. There will be tears. Don't miss out.

Building a complete and scalable deployment pipeline in Python is no joke! HiredScore is largely a Python shop, and we found ourselves empty handed in front of common problems from the Python ecosystem. I will be sharing the best of breed Python solutions that worked for us - giving you a toolkit to avoid mistakes and optimize your dev cycle!

It's considered good practice to get a good look at your data for initial insights before digging into building your machine learning algorithm of choice. But how do you do that in the big-data era, where each point might have tens, if not hundreds of features? We'll introduce the current state of the art methods: PCA and TSNE. We'll take baby steps to slowly build intuition and understanding about how TSNE works and why is it so useful. Examples will be shown in Tensorboard to familiarize the audience with it.

I will tell my story. A story about a dinosaur, Mono in the wild wild front-end. At first look I was naive, I thought I could tackle it with component approach. I realize I got it backwards and my problem was scale so I turned to micro-services. During my work, I noticed that everybody started taking this road, but the results were different and there was 0 collaboration. Recently a new term was born, "micro-frontends", but still the status stayed the same. The story continues with: How I dealt with the unique characteristics of my organization. The problems we encountered and how we overcame them. What I think will be the future and how we can understand and collaborate better

During the talk, I'll do a live demo of building and deploying demo-app from zero logs to hero mode :) Logging was designed in the day's people sshed into the machine (we had just one or two), but as the years passed this is no longer an option. the world has changed and your logging should change with it! We will try to understand why production issues are so tricky to find and solve, and how can we make it easier by building a proper logging system using the latest tools. During the talk, we will review what are the best tools to consider when thinking about logging your app: Jaeger, Zipkkin ,OpenTracing, EFK, Structlogs, kubernetes, Helm and more...

Getting started on on AWS is easy. getting started on AWS Big Data, takes some more time as there a lot of options, managed services, DIY, open source and more. What are you options? What are the considerations for your first Big Data Architecture? What are the challenges of building your first Big Data team?

After 3 years, 1100 meetings with startups (seriously I counted) and a lot of casual conversations with other investment professionals I came to realise that there are recurring red flags that are unique to the situations in which Israeli startups interact with international VCs and are almost certainly not known to most Israeli entrepreneurs. This is not a session about "Israeli aggressiveness Vs. American manners" or the "israeli super technological with no business and marketing" but more a session that explains key differences in the ecosystems and how startups could be perceived negatively due to something that is both explainable and acceptable in Israel. Last year you only had a taste

In this talk, Yuval will share what it means to be a Tech Lead and what it doesn’t. Why should someone aspire to become a Tech Lead and why not. He will also talk about things you can do in order to become a Tech Lead - What opportunities may lead you there and what skills you need to show before becoming a TL.

A main product component at PerimeterX is a web server middleware customers integrate to their infrastructure for us to take action. It is available for all common web applications (NodeJS, PHP, Java), web servers (Apache, NGINX) and edge points such as BigIP, Citrix, Cloudflare, CloudFront, Fastly and more. Most of these are managed as open source projects and published on GitHub, with a goal of keeping the feature map in sync across all of them. I will share our experiences from growing this project to a suite of libraries growing together and installed with some of the largest websites on the internet. I will share how we optimized our methods today to keep the project in check.

Do you have the dream being an independent and stop being a slave of your boss? Do you have a free moment to be self employed? As a freelancer for a couple of years, I'll explain to you what are the reasons not to do so. Of course I'll also explain the what are good reasons to do it and how to do it right.

What leads a company deciding to merge another one? At Singular, not only we've decided to take the leap, but we've done it when we were only 3 years old. In this session, I'll walk you through our story; from the initial conversations, through signing the deal and integrating the teams to launch a new product together (while tripling our revenue). Learn what worked for us, which pitfalls you should look out for and how to create one united and successful team.

Think of the new tools that are taking over the Javascript ecosystem: Babel, Typescript, Rollup, ESLint, etc. 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 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.

“Get data. Analyze it”. For this a system needs to query the data, and for this it needs a query language. Analysts, dashboards and policies require a syntax for queries for certain data sets. SQL is often the default tool for this, albeit having flaws and problems. At Armis we decided to build our own query language. This decision has pros such as abstraction for our users, descriptive consistency across the system and avoiding lock-in to database systems. It also has cons such as development overhead, deep proprietary bugs and constant integration pains. In my talk I’ll go through the decision to build our own query language, the hardships along the way, the fruits that it bore us.

As developers, we solve problems, we handle challenges almost every day. Some developers take their technology, tools, infrastructures and frameworks for granted - they "magically" work. They think that by simply using them, they are considered experts. The truth is that they are "expert beginners". However, there are developers who constantly keep learning, dig deeper and understand why things work the way they do. They are on the path to become experts. They are "Active Learners". In this session, we will learn the necessary mindset, tools and methods to become Active Learners and how to avoid the "Expert Beginner" trap. I'll share tools, methods and stories from my personal experience.

When we decided to base one of the largest Micro-Services-based systems in the country on ASP.NET Core we didn't know exactly what to expect. On our way to (partial...) production we collected a lot of insights, do's and don'ts and made our own list of best practices. In this session I'll walk you through our journey with ASP.NET Core. We'll talk about the decision process, dev tool, pros, cons, and lots more. This was, and still is, a hell of a ride, and we all came out way smarter than we came in. I hope you do too!

We are living in an exciting era where data plans are massive, internet connections are flawless, videos are streaming in 4K and mobile device storage is the size of old PCs. It's a perfect world, so why care about app size? Talking in MBs sounds like an old discussion, but believe it or not - **Size Does Matter!** App size has a huge impact on apps' install rates and not only in emerging markets. In this lightning talk, I will walk you through the actions we took, using culture and technology, in a world where every KB counts. ```sh tl;dr: smaller app size == growth win ```

With more and more developers moving to application development and deployment in the Cloud, there are some techniques and best practices developers should take into account while going through this transition. Cloud is not ‘just someone else’s computer’ and in order to deliver high quality applications, developers should familiarize themselves with those important capabilities. Having 10 years of experience with Cloud Computing, I would like to share my knowledge with new and experienced developers. Gain insight into a variety of aspects, from security to cost to better software architecture, including real life stories and live examples of how to do it right, and what should be avoided.

Have you ever been asked to implement some crazy idea? to scratch your right ear with your left hand? There are all kind of situations in which, as a Data Scientist, you may be asked to use your magic and find a solution for a problem that seems out of your scope. Whether those reasons are business constraints, customers demand, unavailable simple solutions, it all comes down to the same question: Would you accept the challenge? In this talk we’ll explore a real-world challenge and try to answer the following questions: - Does a “Data Science” approach make any sense for a certain problem? - What other alternatives are available? - How much time and resources should be spent?

At some point, I stopped learning... I was happy with my multi-paradigm, general purpose language, its powerful IDE, and knowing every gotcha and corner case of its syntax. I felt unstoppable, my language could do anything! Why would I ever need anything else? And then, something happened. Something, that would challenge my most fundamental beliefs about what it meant to write software. And that something rekindled the passion for learning I thought I'd lost... In this talk I will take you through a journey of re-discovery of programming. I'll show you different programming paradigms and what they can teach us, finally, answering the question: is there a perfect programming language?

Behalf.com has Feature Toggles as the heart of every process. Feature Toggles guide us as we plan, develop, test, deploy and release our code. The journey from Git-flow to Feature toggles was a difficult evolutionary one where we found ourselves at the very edges of what one should and should not do with Feature Toggles. For example, one should definitely not release code to production, LIVE on stage in Reversim - but that is exactly what I intend to do. Join me to find out how that worked out, at the very least you'll have a good laugh :D

A few month ago, I got my new 3D Printer. As a Kickstarter project, it came as half-baked product - its firmware topped with many annoying bugs. In hope to fix some of them, I went to look into the firmware, but alas - it was encrypted with some sort of substitution cipher. In this talk I will show you how I used some data science, statistics, ARM architecture knowledge and much guesswork to defeat the encryption of the firmware. We will see some Python code and I will walk through some IDA scripts I built especially for this mission. Let the firmware's secrets reveal themselves!

Docker swarm visualizer is an open source project designed to monitor a docker swarm cluster. https://github.com/dockersamples/docker-swarm-visualizer This talk will cover: • Container orchestration in general. • Docker Swarm's pros and cons compared to other frameworks. • My personal experience as one of the main contributors to the "Docker swarm visualizer" open source project.

Understanding language is hard; maintaining a dialogue/conversation is even harder- especially for computers. But in recent years, there’s been an immense boost in conversational AI, thanks to the emerging research of Machine Learning and Deep Learning techniques. In this talk, we’ll discuss the challenges in building dialogue systems & bots, the way ML and DL are used to improve Natural Language Understanding in products, and open-source Rasa. We’ll take a look at Lemonade’s chatbot technology, including a deep dive under the hood.

‘When the web came out it CHANGED everything! It took us 20 years to realize that it didn’t change anything! The web has dominated us to think that it’s architecturally significant’ - Bob Martin. Today, many believe that Deep Learning is changing everything - applications don’t have to be explicitly written. But does it? DL projects have many of the same challenges as any other software project while it grows to support more features and use-cases. In parallel, most DL practitioners have little background or passion for Software Engineering. To show the importance of SE for DL - I redesigned one of the most popular DL repos to be at least 10 times easier to read and extend. Join the party!

Have you ever wanted to replace that unsupported, obsolete library, but found it impossible because it’s scattered all over your code? We, developers, engage with third party libraries or APIs in our day to day work. It can even be a library your co-worker wrote, or some framework you’ve decided to use because it’s the best you could find at the moment. In this talk I’ll show how I use third parties in a way that they’re easy to replace and test. I’ll also add in a little bonus and show how you can write specific tests in order to discover breaking changes before you crash in production :)

Recruiting and training engineers is no easy task. Even for experienced engineers. Today's technology stack is very broad and it's usages vary widely from company to company - training is a big challenge. At Outbrain we tackle this with a well defined bootcamp that all engineers undergo in their first weeks. In this session I will present Outbrain's bootcamp and it's benefits and drawbacks.

In this talk I will break one of, in my opinion, the greatest myths of our time regarding code-reviews and pull requests. It is a common belief that before a new code gets to production, someone has to approve it. We feel that pull-requests protect us from production bugs and issues. In this talk, we will try, together, to understand the origins of this process, and after we’ll break some myths around it we’ll be able to understand - does this process really help us? Or maybe it just wastes our time?

Performance review process makes some of us think about the tedious useless process that is mostly time-consuming for all parties and counterproductive. Over the years I have collected a group of approaches based on various references that should unit-test the management skills and provide means of ranking employees. In this quick talk, I will present those approaches.

Real CI-CD working process was our wet dream for long time at Yotpo. We tried to tackle it from many angels and did lots of mistakes in the way. We have very complicated Development arch,with combination of core projects with micro services and different DBs. I wanna show you the current CI solution we implemented. I will present our dev/test environments that rise up with a click and the tech tools we used (Jenkins, Consul, Nomad, Terraform and more..). On top of the environment solution we build super cool CI process based on integration between Jira, Jenkins and Git, This process is working for us and helps our developers to deliver faster and with more quality to production.

Adding an offshore development team to your startup can reduce costs and increase your pool of available developers (luckily for us Israeli developers are in high demand nowadays), but managing an offshore team isn't like managing an on-premise team and could result in having a very high overhead cost. In this session, we will learn best practices for managing an offshore team and how to do it without going berserk.

We thought we had quite an error-proof distributed system at Soluto, at least one that is safe from a major catastrophe. After all, we applied every best practice: micro-services, auto-scaling, automated monitoring and using feature flags. If one service fails, others won’t be affected. But we were wrong, and I accidentally shut-down Soluto's backend with one simple feature for our users. Join me to hear how, but more important - the pitfalls and the possible solutions that could have prevented the situation or reduce the damage, like back-pressure patterns, responsible feature release process and disaster recovery. Basically, things you can do to improve your backend's resiliency.

The demand for fast change is more prevalent and extreme than ever before, and we are working to keep up by adapting our development practices accordingly. Sometimes though even these methodologies to develop in a rapidly variant environment are too restricted for the current tide of our business needs. I will tell you about how I became a certified Scrum Master only to progressively discover that implementing its total methodology is detrimental for my team at our current state. Let’s discuss the real meaning behind the buzzwords. We'll diagnose what our teams and companies need most and find the best practices to boost our efficiency, productivity, and ability to deliver good code fast.

Ownership is often an unspoken, under the hood subject which no one wants to discuss. But, I strongly believe lack of ownership of people is where companies fail. it's where company culture begins to deteriorate and poor quality products are delivered. History proves it, but the future can be owned by us! In this talk I will show you why embracing extreme ownership in almost every thing you do will help both you personally and the organization you work for tremendously. I will also provide a number of key takeaways for you to use in your daily work whether you are a manager or developer, seasoned or junior.

One of the key aspects of a solid data solution is reliability, as customers entrust their most valuable assets in the system. When it comes to data platforms performing at 100K IO operations per second, failure is eminent. In this talk I will present the basic hypothesis – “shit will happen” and go over the strategies to recover and maintain service in highly distributed, high-performance, micro-service driven architectures.

Distributed systems can seem magical, and sometimes all of the magic works and our job succeeds. However, if you've worked with them for a long enough time you've found a few places where the magic starts to break down and the fact that it's actually a collection of several hundred garden gnomes* rather than a single large garden gnome. This talk will use Apache Spark, Beam, Flink, Kafka, and Map Reduce to explore the world of data parallel distributed systems. We'll start with some happy pieces of magic, like how we can combine different transformations into a single pass over the data, working between different languages, data partitioning, and lambda serialization. After each new piece of magic is introduced we'll look at how it breaks in one (or two) of the systems. Come to be told it's not your fault everything is broken, or if your distributed software still works an exciting preview of everything that's going to go wrong. Don't work with distributed systems? Come to be reassured you've made good life choices.

In less than 24 hours, my team and I built a platform that takes natural language questions from Google Home and execute real-time queries on big data and represent results with speech and a graphical user interface. This project got us to first place in Iguazio’s hackathon, is being used by several Iguazio customers, and now I’m going to spill the beans and share exactly how we did it. In this session, I will cover how to leverage serverless functions, Presto and external SDK’s such as Google Maps, Google Dialogflow and React to build such projects and present a live smart mobility demo.

As service/product provider you want to make fraudsters sweat for every cent, without affecting legitimate users. Fraud occurs every minute of every day, it is a matter of volume to get you to do something about it. Traditional fraud prevention involves business rules, however today the main approach is to use AI, Machine Learning algorithms for this. In Gett, we found that we must have both sides, as algorithms need a large amount of data to be effective. I will focus on Rule Engine implementation, describing how you can decouple rule writing from rule execution and show a rule engine written in JavaScript, executed inside GoLang Service.

Are you familiar with the situation of coming to work and having a hard time focusing on your missions? Do you sometimes work on a mission when suddenly after an hour you are incapable of doing anything useful for a couple of hours? The Pomodoro technique is here to deal exactly with that. In the lecture I'll explain the Pomodoro technique for managing time and how it changed the way I work. We'll talk about how to use it, when it is the right thing to do and when it is the not-so-right thing to do. In addition, I'll give you a few tips from my own experience.

As a first time team lead, I thought my biggest challenge was to learn how to manage people. Unexpectedly, I found myself fighting to stay afloat on a wild sea of project designs, code reviews and syncs. It took me a while to realize that my focus should be on my time, and on learning how to manage it. I developed a set of techniques that kept me sane, and stopped me from becoming a bottleneck for my team. In this lightning talk I'll share some tips for first time managers, as well as the personal tools I use for time management. If you're managing people or a project and struggle to find time to do everything you want to do, then this talk is for you.

The story of a company that went through a **paradigm shift** - from a classic, reactive, siloed "Operations Team" into E2E full Service Ownership by R&D. I will be discussing our vision and its value, the challenges along each phase, and the **practical steps** we took within SundaySky to reach that goal. As the "DevOps mentality" is very unique in each company I will try to leave enough time for **Q&A** in order to tackle the audience's personal challenges. Target audience is R&D, Infrastructure, DevOps, Product and Engineering in general.

Contributing to Open Source has many benefits. Learning from more developers about coding paradigms, other technologies, and different takes on software development. You may even have thought about releasing some of your own or your company's code to OSS, sharing your experience and expertise with others. Last year, I did just that: releasing components and frameworks we use in Shop Your Way over the last 10 years for everyone to use and see. In this session, we'll talk about what you need to think about when you want to release a pre-existing piece of code to the the public, what the team can gain from having OSS project, the obstacles you may stumble along the way and how to overcome them.

Many of us have usage metrics baked into our products to gain a better understanding of how our product is being used, and to be able to optimize our products based on this data. But sometimes this isn't enough. Many times we have premium customers, with production-grade SLAs, and being able to correlate usage with specific clients, would enable us to provide a better experience for these users. This talk will demo how we used a serverless function to manipulate our setup file to attach a unique identifier to each usage metric, so we can optimize our customers' experience, and improve our quality of service.

The everyday goal of developers and DevOps is high quality software delivery in high velocity. Security is not their focus and we believe it should not be a burden as well. Security should be natively and seamlessly integrated into the tools and platforms developers and DevOps use, so it will become effortless. Conjur Open Source is a security solution built with developers and DevOps in mind. It can free the developers to do what they do best – develop great software – but without compromising their security. In this session I will introduce Conjur Open Source, walk through how native and easy security can become and how you can get started and contribute – right after this session.

_There are places where_ - R&D security and product managers have constant fights over security and risk - Security champions, who are good developers, are not really security people but no one else wants to deal with security - Security architects serve as on-demand resources and only help when called #### It doesn't have to be that way! ### We can have good security and keep everyone happy _In this talk_ I will share the experience that we gained at CyberArk. How our risk driven product security approach overcomes all of these challenges, improve security and innovation and harnesses everyone's contribution (developers, QAs, PMs, security champions and security architects)

In this talk I will compare Java, Scala and Kotlin, to show where each language shines and what are differences and when/where I think each should be used. The talk is based on a blog post: [Scala--pack your bags; Kotlin is coming!](https://medium.com/@OhadShai/scala-pack-your-bags-kotlin-is-coming-5169f737cfe8) and talks I did about Kotlin.

Whether you are a developer, a team leader or a product manager, your role involves making decisions on a daily basis. For most of us, making those decisions can be hard. This presentation is a cheat-sheet on how to hack your decision process. Using only a few easy steps and a cheap gadget, your decision-making process will become faster and more efficient.

E2E testing needs to adjust itself to the new Agile world . Today E2E testing must move quickly and work in parallel to development . The result is no idle time for automation and fast feedback to the developers . I will share our team's experience with E2E Automated testing.

Every product that we choose to use, or design for users that make a choice to use it has a trial period, whether it’s limited to X number of days or not. When we build a product we think a lot about our users and the features that will solve their problems and make their lives better, but we often forget to think about the new users, those who don’t know our product yet. What is the process that they need to go through to get to value? In my talk we’ll discuss why so many users drop-off during the trial period and how we can design it to bring the maximum number of users to experience value from our product.

Distributed Tracing is the most useful tool you’ve never heard of for debugging and understanding your microservices. Having spent one too many evenings doing stack trace detective work, I wanted another way to debug issues. So I set up a Distributed Tracing server. It enables me to uncover latency and inefficiency, pinpoint bugs and, in general, make sense of the chaos that is microservices. In this talk I’ll introduce the Opentracing standard, demonstrate the benefits of distributed tracing and how to get started with it. I will cover basic uses, best practices as well as some pitfalls to avoid.

In a microservices environment, it's common for any service to make remote calls to another services across a network. By design, remote calls can fail, or hang without a response until some timeout limit is reached which can lead to cascading failures across multiple systems. In this talk we are going to cover Outbrain's strategy of implementing circuit breakers and treat every micro service as optional, allowing us to run our system using hundreds of different micro services with 100% success

How does Messi know where to run when Iniesta holds the ball? How can we tell if a user is performing a fraud using our system? Even we, as human beings, don't always excel at these tasks. Plan Recognition is a key problem in AI that can be phrased as follows: When you observe someone else's actions (a user, a robot, a collaborator), what is that someone trying to do, and how? In this talk I will share my experience with this research problem, the unique challenges it can tackle and a use-case of my plan recognition work with a major financial company.

Web applications become more and more complex nowdays. Data is streaming faster and in bigger quantities and the users expect a smooth "native" feel to the app. In this talk, we will go through optimization design patterns from the gaming industry and see how they are applied to web applications in order to improve performance and squeeze a bit more from the end user's machine.

Organisations struggle with testing their microservices architecture. The Pyramid model, staging env. or QA team, reduces development velocity. The Diamond model, which we at Logz.io have been using effectively for the past three years solves these challenges by focusing primarily on the microservice as the unit of work being tested. In this talk, I’ll explain how Docker enabled this model and how Testcontainers come into the picture. I will show what the testing dichotomy looks like in this model, while providing concrete examples for each type of test. I will show a demo of a test using Testcontainers, and end with a bottom line summary explaining the reasons we chose this methodology.

Hybrid Infrastructure - Many companies talk about it but only few actually implement it. This talk will describe the journey we had while migrating our research environment from our ones hardware to the cloud. It will include the challenges we had, the different steps we walked through, some useful tips from our own experience and a summery of what we achieved (and we achieved a lot!!!)

Everyone knows how to build a monolith application. But nowadays trends and technologies require other approaches and other skills. People today strive to build distributed applications. It's not easy! In this discussion I will present a simple and practical introduction to a few patterns that will help you to build your next distributed application. We will start from a short journey to the history of classic monolithic applications. After that we will see the gradual evolution from those monolithic architectures to the real distributed event-driven applications. I'll provide you with the tools and knowledge you need to start designing and developing your next distributed application.

Python has a super rich and active ecosystem and py.test is great, but is it enough for doing great TDD and BDD? Is it expressive? Does the framework work for you or do you find yourself working for the framework? Using the Nimoy framework I set out to make Python testing beautiful, expressive, pragmatic and fun, and help your code live long and prosper.

Cloud is the dominant computing platform, but is it nearing its end? New workloads like IoT, autonomous cars, video analytics, VR and AR require lower latency and higher throughput. 5G networks will only solve bottlenecks at the last few miles and therefore analysts predict that clouds will evolve and become distributed. This session will cover the current cloud architecture, challenges, the emerging distributed cloud, aggregation (“fog”) and edge architectures. We will share tips, best practices, and show a live end to end demo. Developers and architects will learn how to prepare for anticipated changes which may impact their products, as well as identify potential opportunities.

Automating HTTP load tests can be challenging since it requires parallelism, various request functions such as GET or PUT and dealing with high loads, all asynchronously while performing other tasks. In this session I will introduce the HTTP Blaster - a Go lang open source tool which allows users to blast a system with HTTP requests dynamically and easily. I’ll show how HTTP Blaster supports multiple use cases and how developers can use it to leverage new and existing tests.

Do you know Kubernetes? Do you have experience with Terraform? These are the questions I am usually asked by companies when they think about introducing DevOps. They usually think that what they lack is an expertise in using the cloud, however in my experience that’s not the main problem. So how do you get started with DevOps? In this presentation we are going to step through a number of actions that can help you move in the direction of faster and more stable release cycles. Steps to start using the cloud. We will look both a top-down introduction of DevOps, when management wants it, and a bottom-up approach when individual engineers decide they want a better work-life.

At Fiverr, we’ve been constantly evolving our architecture to solve business and organisational challenges. We scaled our web site to become one of the 500 with highest traffic rank in the world by breaking a monolith. Then we scaled our software platform to support our development team growth by adopting micro services paradigm. In this session I will present the latest version of our architecture. I will show how new architecture is designed to address the challenge of achieving dev teams autonomy. I will also show how we implement the new architecture by moving from a traditional centralised database approach to Event Sourcing using streams of changes as a source of truth.

"grav" (https://github.com/epickrram/grav) is a collection of tools to help visualise process execution. It was started by a colleague of mine, Mark Price. After I joined the project we focused on flame graphs, specifically for the JVM. Flame graphs are a new and extremely interesting approach to visualise process execution. Our open source project focuses on viewing Java threads "flames", showing how we can visualise heap allocations and most challenging, exploring how to visualise progress in a flame graph via animations. For example, we can now see for the first time how a JVM starts interpreting code, compiling hot paths via JIT compilation, executing them and collecting garbage.

How can you get a legacy codebase under control and bring it to a new level of maturity? what is a legacy code? In this talk, I will talk about the technical debt- believe it or not,, it's not only old code that can be considered -LEGACY- why we have legacy code and best practices to approach it

Display and computer keyboard/mouse are not the only possible ways for your programs to interact with users. On the other side, modern sensors and actuators became very "smart", affordable and easy to work with. In my session I will present a couple of simple solutions for building production-grade electronic devices that any software developer without thorough knowledge in a hardware can put together and use in their projects.

Five years ago we decided to store each customer's data in a separate collection. While customer-level isolation might sound unnatural to multi-tenant SaaS like BigPanda, we thought it would be more secure, scalable, and manageable. At the time we weren't convinced that we'd made the right choice. As the product developed, however, we found it to be an invaluable design decision and adopted it throughout our system. In this presentation we'll share how customer-level isolation is implemented across our stack, the architectural impact and the business use cases it serves. We'll also talk about the challenges we encountered along the way, the solutions we found and some inevitable trade-offs.

The graphdb world hasn't changed much for the past couple of years, the same major players applying the same old know techniques, when I started creating my own version of a graph database, I followed the same path, but to make a difference and really standout in the crowd something had to be done differently. This talk will introduce you to and guide you through what I've learnt in the past two years creating the fastest graphdb today using basic mathematics, I hope your linear-algebra is polished!

Super heroes are an integral part of pop culture. They entertain us and inspire us. With technology moving so fast it seems like we are one step away from a real life Tony Stark. Together let’s explore and discuss how sci-fi heroes can help create the first real super heroes through inspiration and STEM education.

From the early dawn of software development, there's been a clear separation between teams: Backend, Frontend, Ops, you name it. This separation created cultural silos, rarely breached. In BigPanda we decided to embark on an EPIC quest to break down those walls, and create feature teams that are fully complete, with multidiscipline engineers, dealing with all aspects of R&D, including Operations. In this talk we'll cover our journey and challenges to achieving equilibrium within our teams, enabling the teams to move fast and independently.

חדשות לפרקים אנו שומעים על פריצה לחברה או לאתר; האקרים המנצלים באגים בקוד על מנת לבצע פעולות זדוניות שונות, כגון: גניבת מידע, שתילת כופרות, או אפילו הרס מוחלט למערכות מיחשוב. פיתוח קוד בעידן הווב קיים כבר למעלה משני עשורים – מדוע עדיין לא למדנו לעשות את זה "כמו שצריך"? המיומנות לכתוב קוד אינה דרישה מספקת עבור מפתחים בימינו. האם הם מודעים לסוגי הפגיעויות שהם עלולים להכניס לקוד שלהם, והאם ברשותם היכולת לפתח קוד באופן מאובטח? על מנת לסייע בכך, יצרה עמותת OWASP את ה-"OWASP Top 10": רשימת הפגיעויות השכיחות ביותר בקוד! בהרצאה ננתח מס' אירועים בולטים מעולם הסייבר שאירעו בשנים האחרונות, ונמפה את מקור הבעיה בכל אחד מהם לפגיעות מסויימת מהרשימה, אותה ניצלו ההאקרים על מנת להשיג את מטרתם.

It is not uncommon to hear about how elegant Functional Programming is. Granted, some notions of beauty do have their place in the world of software development, but that alone is not a sufficiently compelling reason to endeavour into the unknown. In this talk, I will describe my (somewhat idealized) journey from the world of imperative, Java-style programming down the never-ending path of Functional Programming. We will be motivated by simple and relatable concerns, such as: the wish to have less bugs, to write simpler tests and to have altogether more predictable software. This will almost inevitably lead us to re-discover and embrace Functional techniques and the benefits that follow.

How to improve R&D support and affect business, How to reduce SLAs. Improve communication with business What affect it has on business, how to do it in a very short time. And how to maintain it. _______________________________________________________________________________

As researchers and developers, we constantly face new problems, and challenge existing solutions to old problems. On beautiful circumstances, solved problems from one domain shed light on new problems from totally different domains. This happened to me while I was researching a Ride Sharing problem of optimally grouping multiple riders on a single taxi - a DNA Sequence Alignment algorithm gave inspiration for a hybrid solution, that turned out to be significantly more efficient than the original one. By sharing with you this story and its resulting algorithm, I hope to entertain your curiosity, spark your creativity, and encourage you to venture into unexpected solution spaces.

Modeling user preferences in sparse, large scale deep learning environment is a non trivial task. In this lecture i will describe user preferences modeling technique that convert the user long term history preferences into a vector representation using attention mechanism. I will show how the attention dynamically changes the user representation based on the specific context and different target items.

It still amazes me to see the basic security flaws over and over again on every site that I check, All of those security breaches can be prevented and closed quite easily. In this talk, I will explain and show basic security flaws in web applications - how to detect those and how to make sure that your application or web site will not have those.

We've all been there - startups innovate, and large companies acquire startups as their innovation engine. Why do large companies come to a technological stall? This talk is about infusing the technological innovation into the large companies and why it usually fails. I'll show several models which will help you understand why these attempts have failed in the past, and what is actually needed to make innovation happen in future.

Downtime sucks. Especially if you're running a high-scale environment and every minute you're down, you're losing lots of money. Our experience at Jelly Button with 4M daily active players taught us a lot about how to prevent downtime and how to effectively deal with crises. In this session, I will present our guidelines for downtime prevention and management, talk about best practices and effective communication. Relevant for both cloud and on-premise deployments.

In our industry, there is a clear differentiation between B2C and B2B. And while the business models and sales funnel can be different, we tend to have a different approach in terms of UX and product. But, why? The people that are using our products don't stop being consumers the moment they enter their office, and the high level experience they are expecting from the apps in the their pocket don't disappear when they sit on their desks. In this Lightning talk I am going to share some examples, the lessons I learned from working in a startup that creates medical devices for doctors and nurses all around the world, from Africa to the USA.

Analytics is not “just” firing pixels. As you product grows, you analytics requirements become more complex and require more synchronization. In this talk we will understand the main challenges in maintaining analytics for a big system, having more than one platform, and keep analysts, developers and business managers in the same page.

Let’s face it, Business Intelligence and Analytics as we know it are dead. These functions are slowly being replaced by automated software and these roles are slowly being converted into Data Engineers and Data Scientist. So why do we keep hiring analysts in the market? What should organizations’ Analytical hiring Strategy be? Is there still a place for analytics in organizations? What role do Data Scientists play? How can organizations get the most value from Data Science? These are just some of the questions I will answer in my presentation. After this talk, you will have an understanding of how Analytics are evolving and how your company can benefit from Data Science.

The GIS software market is historically based on expensive proprietary software, which creates vendor locking and sets an entrance barrier for organizations who want to use such technologies (e.g. think of your local municipality). In recent years, we see more and more Open Source GIS software available, and the business around it starts to get disrupted. It still hasn't spread into the market, but certain sectors already adopted it vastly. This talk will cover the various revolutions happening and which could be adopted quite easily for your benefit.

Measuring page load and server response time was used for many years as the standard for our website performance, however, as we all know this is not a true indication of the user experience. As the time goes by, it becomes more and more clear that these metrics do not represent the actual user experience in the era of SPAs and PWAs. PSI (Perceptual Speed Index) is a metric that aims to solve this issue. In this talk, I will explain why is it important to measure PSI, the different approaches to measure it, how we do it at MyHeritage, and what we’ve learned.

For 4 consecutive years I got declined from Reversim conference. I was really really close to get in, but failed. This year I got accepted! twice!! In this presentation I am going to reveal how did I do it, and will guide you how to do it yourself. I'll explain how does a mix of the Pygmalion effect, Conscientiousness trait and agile mindset can lead you to the promise land.

Subscriptions on mobile are becoming the new SaaS, responsible for massive revenue growth in the app stores. In this talk we will cover all the shiny new tools and capabilities released by both Apple and Google for subscriptions on mobile. We will have it all! - technical details, benefits, challenges and a comparison between the platforms, all in 30 minutes or less :)

The tech giants made great efforts to make Deep Learning more accessible to the general developers community. However, although it is much simple to use/train a neural network, it is still hard to comply with production constraints, in sense of running times and cost. In this lecture we will review the different ways in which we can make neural networks more efficient and cost effective while preserving their quality. I'll review the several techniques for model compression - e.g: knowledge distillation, pruning and quantization. i'll talk about several works in the fields and how to use and implement them for your own use.

Imagine a world, a world in which the city we live consists of components that were designed and built by the population. Imagine a startup company that creates all the code as a self-development, without use of any commercial components In the past quarter of the century, our perception of how software projects develop has completely changed! I'd even say Who Moved My Cheese? In this talk I will present my view about of one of the main reasons for the change (positive change?) Development based open source community

More of today's applications are being built from smaller components and modules. However, the workflow around building with smaller components can also generate a lot of overhead. Bit is an open source project which helps developers discover, use and collaborate on shared components while distributing the development process itself. In this talk I will introduce Bit, talk about the challenges and opportunities of building a core piece of your technology with the community, the challenges of having to play hand in hand with the rapidly-changing open source ecosystem (from Git & NPM to Webpack and React) and share some insights for teams who want to open source some of their projects

Company growth is often accompanied by the growth of the number of developers, features, and responsibility. The legacy structure “Developers vs Operators” is not solved by adding “DevOps” team. Playing hot potato with escalation process is constantly depressing, demotivating and the most terrible, splitting the team. In Yotpo history scaling from 4 to more than 100 services we passed all these stages and came to the obvious solution: “You write it - you run it!”

Over the last 4 years the (real-time) Attribution team at Appsflyer has been successfully evolving the same set of micro-services. However, for a long time the engineering team has felt the attribution flow has "unfixable" flaws, AKA technical debt, A complete re-write was decided upon, with a totally new architecture design: a risky, bold decision. In this session, I'll describe the rollercoaster process of harnessing the entire organisation (R&D and business) with the development and risky migration process of all our traffic and customers to a completely new set of attribution micro-services. we'll cover the good and bad decisions made, and the agility needed from everyone to succeed

Did you ever join a new company, just to find out no one had any idea what to do with you? You're not alone. Software Organizations invest so much on optimizing talent sourcing and work processes, it's amazing how the link connecting the two – engineer onboarding – is often neglected. In this talk, I'll point out common "Anti-Patterns" in engineer onboarding, mixing comedy and tragedy. I'll touch some of the underlying reasons why these mishaps are so widespread. Finally, I'll describe the onboarding program at WeWork, and share what we got right as we brought 50 engineers up to speed both technically and culturally in under 3 weeks (Hint: it has to do with empathy and lunch).

We're all using TypeScript/Babel etc, transforming our code to another code, minifying it, shipping this unreadable thing to production and using the magical powers of Source Maps so we could actually debug it and understand how it connects to what we initially wrote. But did you ever wonder how Source Maps actually work? Join me to find out!

Most presentations in the software world describes a positive achievement of sorts: a feature added or a bug removed. This presentation is different. In this presentation we shall describe how we deleted over 4000 lines of code, together comprising 30% of the code base of a complex device driver, without even trying. Last year my team started working on refactoring the Arm CryptoCell device driver for the purpose of integrating it upstream. While doing so, a pattern emerged - almost each set of changes would reduce the code line count, and yet the functionality stayed exactly the same. This presentation explains how and why we cut 40% of the code with no functionality loss without trying.

Scheduling and executing predefined periodic tasks is something each company requires sooner or later. In this talk we will cover the possible requirements from a robust job scheduler and share the easy and simple solution we've implemented at Trax by combining several out of the box basic AWS services. Building the new system took 1 sprint of 2 developers, replacing a system which costed more than a year!

Have you ever received an email from your aunt saying paracetamol is dangerous because it contains a rare virus? Heard in the news that kids don't need antibiotics? Read online that garlic is enough to stop rabies? We are surrounded by bits of information, many of them are false. Some of them are dangerous, and could hurt people's health or even cost lives. In this brief talk we will learn how to identify fake news and how you, too, can help make a healthier society.

Are you satisfied with your career? Do you feel that you can express your full range of skills at work and fulfill your potential? Are you afraid to leave and start a new adventure? Identifying and creating your life changing opportunities while trying to balance your work and personal life can be a challenging task. But done right, these opportunities can take your career one or two steps forward. In this talk I will share advice and tips from my experience of how to navigate yourself and your career to the place you want to be, identify and create your own life changing opportunities, and manage to do it without sacrificing your personal life on the way.

With the rapid adoption of microservices, there is a growing need for solutions to manage deployment, resources and data for fleets of microservices. Kubernetes is an orchestration framework for containers that is rapidly growing in popularity. Apache Kafka is a streaming platform that makes data accessible to the edges of an organization. It's no wonder the question of running Kafka on Kubernetes keeps coming up! In this talk, we will help you navigate the hype, figure out the terminology, address frequently asked questions and help you decide if running Kafka on Kubernetes is the right approach for your organization, and if it is - what do you need to know in order to make it happen.

Long code reviews might be a tedious and error-prone task. But there's a better way! By applying principles, similar to those of Clean Code, on the way we structure our commits along the development of some feature, we can achieve a concise Git history that tells a story. This unique methodology has many advantages including easier and streamlined code reviews, simpler mental models during coding, a better documented project and more. If you care about your software engineering craftsmanship and stuff like Clean Code and SOLID are close to your heart, then this talk is for you!

When the company shifted to use Spark, a big knowledge gap was created between the teams that already devour the framework internals and others who didn't have the chance/will to do so. Therefore, I created an internal Spark training for the experienced developer. Along the way, I faced some push-backs mostly from experienced developers and would like to share with you how I survived.

When a b2b startup is small, and deals are oxygen, customizing your product to tailor for a customer's need is not an nice attitude, but a business strategy. The ability to quickly and efficiently extend your code, and ship it to your customer within hours, becomes a very important edge in a highly competitive market. However, with great flexibility, comes great complexity, as when your company grows, your custom solutions must keep on working smoothly, without affecting your core product. In this talk we'll discuss how at WalkMe, we turned pain into initiative, and grew our code infrastructures and delivery systems, from early-day hacks into modern-day plugin systems.

So you've decided to switch job, and you wish to make the next place's experience much better then the prevues one (after all we all want to make more money/ learn new technologies/ meet new people or any other reason to switch job). BUT how can you know if this is the right place for you? In this lightning talk, we will go over few patterns and signs I have learned to identify in my many years of job seeking and recruiting.

.Flaky tests—tests that fail sometimes but not always—are a universal problem. In this session, we will discuss a new and simple approach AKA "under_test" . With the new approach, we not only reduced the number of failures due to flakiness by more than 90% , we also increased both our test coverage in successful cases by 20% and the number of real bugs caught! https://blogs.dropbox.com/tech/2018/05/how-were-winning-the-battle-against-flaky-tests/#.WvxhjCe1K7E.linkedin

Development in some open source ecosystems is very different in nature from regular 9-5 development. We’ll talk about the surprising ways open source is different from regular development, the importance of people, technology and teamwork. We’ll go through real open-source changes affecting millions of developers in Node.js 11 and Node.js 12 and see how the people behind them work and how to get involved yourself.

Wix is a major contributor to the React Native community, building and maintaining few of its major open source projects. Building, testing and publishing complex React Native projects requires mixing many technologies, from building Java/objC/JS, running and managing tests on iOS Simulators and Android Emulators. We evaluated 3 types of solutions, fully SaaS (i.e. Travis CI), IaaS with some SaaS (i.e. Buildkite) and IaaS with Jenkins. We decided to go with the last option, since Jenkins is a well known open source, with many plugins and it fitted our use case.

In a startup that scales quickly, there is an unconditional need to be connected to the numbers and work efficiently without wasting time, We have built BigBrain to help us do that job in a single place without loosing context and FAST! During this talk you will understand what is BigBrain, How it was built, the key decision that took us to this place and the value it brings (At the end i think you will choose to adapt some of it to your company) BigBrain enables us to: * Spend 4.5M$ efficiently per month using sophisticated Intent model, * Take conscious decisions using A/B tests * Runs our entire Sales & Partners flow * Help us maintain <7 minutes response for our customer success

Shortly after we began developing at Logz.io, we began to envision a development environment in which developers would be able to develop a feature, end-to-end, without relying on other teams. This vision was, and still is, based on a value of accountability that is part of our culture manifesto. In this talk, I will unfold the journey we made as a company to the current state of things, where development is 100% self service -- from design to coding, testing, deploying, monitoring and debugging. This story includes Docker, Kubernetes, Apollo (our open source deployment app), Jenkins and processes and methodologies we adopted and enhanced (e.g. The Diamond Model for testing).

Reinforcement learning is an area in unsupervised learning that deals with learning out of experience. The machine can be described as an agent, taking actions in an environment and getting feedback, while trying to maximize some reward. Deep learning models achieve very impressive results in reinforcement learning for playing games such as chess or AlphaGo, and recently even won some world class players. In this talk I will cover a deep learning approach to play the 2048 game - using popular techniques such as fully connected and convolutional neural networks. We will cover a simple trick, which as it turns out brings impressive results with very few trials.

Everybody knows that successfully scaling an engineering team requires major cultural adjustments. What few people know is that scaling an engineering team also entails (surprise, surprise) major engineering challenges. These challenges include puzzles such as: a single repo or multiple repos? how to share code within the team? what is the right procedure for committing changes to shared code? how to manage build dependencies? is it even possible to keep the trunk Green? Should each service provide its peers with a client library to wrap its REST API? (and how thin or fat should this library be?) In this talk we will dive into these topics, and discuss the trade-offs of various solutions.

Good news! A new engineer is joining the team, and your manager appointed you to be their mentor and guide them through those first few turbulent weeks at the company. Great! Now what? This session will serve as a quick-start guide to the new buddy. I will present an outline for the onboarding period, from preparations to closure. I will also share some tried and true tips that helped us boost the newcomers' experience at WeWork. Finally, I will try to convince you that mentoring someone new is the best thing that can happen to you professionally.

Monitoring high-throughput services is complicated, even more so in a continuous deployment world. It's difficult to map all user inputs and validate them pre-launch. It's also difficult to simulate system failures, like network & disk errors. Verifying that the service operates as expected is not trivial at all. In this session I will share best practices and guidelines we adopted at Outbrain for monitoring services.

Once you start working with Big Data systems, you discover a whole bunch of problems you won’t find in monolithic systems. Monitoring all of the components becomes a big data problem itself. In the talk, we’ll mention all of the aspects that you should take in consideration when monitoring a distributed system using tools like: Web Services, Spark, Cassandra, MongoDB, AWS. Not only the tools, what should you monitor about the actual data that flows in the system? We’ll cover the simplest solution with your day to day open source tools, the surprising thing... that it comes not from an Ops Guy.

Supervised learning is great, but is it always the optimal solution? When telling the difference between cats and dogs there's always enough training examples. But what happens when you’re looking for an extraordinary phenomenon such as a unicorn? Our unicorns are DNS exfiltration attacks, such as the 2014 cyberattack on Home Depot, resulting in the theft of 65M credit card numbers. In this talk we will discuss the advantages of Anomaly Detection in the absence of training samples and the challenges we faced migrating it to large-scale Spark Scala. This is the story of how we had to take a different approach to our problem and how we got to catch a live ‘white-hat’ cyberattack on a client.

Motivation matters. Even the most professional teams deliver better results when they believe that the work they are doing is important. They'll also be happier, and stay with your company longer. So what's the trick? How do you keep a team motivated and show them the impact of the features they are working on? In this talk I'll show you how to incorporate motivation into the produce development cycle. I'll talk about my personal experiences at BigPanda and demonstrate how these techniques made the team better, closer to the business and more engaged.

What is the difference between a clean code and an organized code? How come an organized code can be a confusing code? Which code comment is a beneficial one and which isn't? The lecture is about the principles of clean code, which problem it's intended to solve and why it is important. The lecture will include the philosophy behind the principles and will cover the main rules of the method.

During 2015 my co-founders and I raised approx 1M USD in seed funding from 4 investors, for a company we started after we worked together for a few years at Conduit. Fundraising is a marathon, and I'd like to take you through my personal one. This is my “via de la rosa”, it’s full of the painful details. It is not a generic "best practices" presentation. I want to share my real side of it, and speak plainly about meetings I had, pitches I screwed up, and ridiculous arguments I got into. The entire fundraising journey trains you to be efficient in processing your feelings, it is incredibly humbling. But It is also uniquely effective as a conceptual playground for your pitch and your product.

At last year's Reversim, Iftach Bar gave a beautiful talk called “Lets talk about your salary”. He taught engineers how to negotiate their salaries when getting hired. But while salary negotiation is hard for candidates, it's practically a nightmare for employers. When we hire we're faced with the impossible task of evaluating the potential value of a perfect stranger to our company, knowing that the cost of being wrong could be extremely high (especially for startups). In this presentation I will share how at BigPanda we try to minimize that risk so that eventually both sides are happy. It'll also give candidates a chance to better understand how managers think when making offers.

A conflict between containers and functions? We’ve been shifted to containers and now all vendors tell us to throw it away and unpack our code? Maybe we can combine the two. In this talk, I will review the different possibilities of shipping Containers as Functions as oppose to FaaS Vendors' standard Functions implementations. I'll actually demonstrate how to write C code and run it as a Function! Moreover, I will talk about the importance of Multi-Cloud & Functions, how we can save a ton of money, improve our service's SLA & leverage the "cloud" it was meant to be.

Have you had the chance to work remotely on an engineering project? Post Singular merger, I experienced first-hand working together on a project with an engineer from San Francisco (10 hour difference) for 6 months. Working remotely on an engineering project is kind of like maintaining a long distance relationship - it requires constant communication, effective calls, maintaining work-life balance and something to laugh about. I would like to (quickly) present what worked, what didn't, and my recommendations if you ever think about doing that.

Monitoring the performance of backend systems is a well-known practice. Many technologies, tools, guides and best practices are available, thus every bit that moves within your data-center is tracked and measured. It is great, but your users couldn't care less about the performance in your data-center, they wish to get great performance in the web app. In this talk, I will share with you how we leveraged the technology and tools we have around backend side monitoring, to have great monitoring for our web apps.

The world of CI/CD forced software engineers to be more disciplined and take ownership of testing. Verifying that the code works as we expect, performs well and integrates with other systems is common practice but automatic check that acceptance criterias are met less so. Why is that? What is so hard about acceptance testing? How do we define it and where is its place within a CD pipeline? What can we learn from past mistakes and what approach works in practice? The talk will cover my experience with acceptance testing in two companies (LMAX and eBay), what pattern worked for us and how can we turn acceptance testing into a legitimate and effective tool.

I front-end today, we are almost always dealing with abstractions - a framework mediates our interaction with the DOM, a library wraps our events, heck, we even have a library enforcing types. Even though we don’t always see it, underneath it all is still good-old JavaScript and web APIs, and it’s worthwhile to know what our abstractions ultimately translate to. Not only will it make us better developers, not only will it make us better “abstraction-users”, but also - it’s something we are all completely capable of. So let’s dive into two such abstractions - ReactJS’s component lifecycle and Angular’s EventEmitter - and look at the source code and the nuts and bolts that make them possible.

I've seen it all... C, C++, VB, Java, Python, Scala, and finally JavaScript. Yes... JavaScript... For years it has been forsaken, laughed at by the big industries... but just like the Energizer bunny, it just keeps going on and on. With my 30 years of experience I'm going to go DEEP, and analyze exactly why did JavaScript took off, and more importantly, why should you bet on it for the future...

Micro-services architecture holds a challenge for continuous integration. Many services need to 'play' together in harmony, most of the time with some frontend involved. In our case - web and 2 mobile apps on 2 platforms. The CI process needed constant improvements and optimizations to keep up with our agile culture and business goals. In this talk, we'll go over some of the challenges we've faced and steps we've taken, and give you some tips from our experience. We'll try to answer questions like: How to move into CI/CD from semi-CI/CD? Can the CI be evergreen? Is this what we want?!

HBase coprocessors move data aggregation from the client to the database Server. Coprocessors provide major performance advantages, but programming coprocessors is challenging because the development cycle for coprocessors is slow, tedious and somewhat dangerous. Our solution is to embed a Clojure interpreter inside an HBase coprocessor and to provide Clojure code for aggregations with each query. Our coprocessor then dynamically compiles the aggregations for each query allowing for rapid development and testing. Extension of this approach to other JVM languages like JRuby or by using GraalVM should be possible. Code and examples are available on GitHub.

We’ve all heard it. The “business guys” want everything done, working perfectly, yesterday. The devs on the other hand say it’s not ready, any of it, ever. Such extreme stereotypes are rarely accurate, but the inherent business <-> R&D tension is very real. In this talk we’ll discuss the differences in perspective and language between the different roles in a tech company - and understand how can everyone be right while holding opposite opinions. We’ll then go over several tips on how to communicate the dev point of view in the language of business - while making sure everyone are aligned around the greater good of the company.

Get your phones out of your pockets - in the next few minutes, a Virtual Reality world will emerge inside your browser, created live with WebVR - with just a few lines of simple HTML code. Let me show you how - here comes the magic! ✨ WebVR is an emerging standard that enables building VR experiences across a wide range of devices, such as Google Daydream, HTC Vive, Oculus Rift and others. In this session, we will see how we can quickly build a VR world in just a few lines of code - no previous 3D or OpenGL experience is needed. We will live code it together, and you will get to enjoy our VR experience on your own phone as we create it. Let's get creative!

Elastic Search is, you know, for search… but in recent years it is no longer only for search. At Sears Israel, we use Elastic Search to power our main recommendation and discovery experiences, to allow our shoppers to discover interesting and exciting new products. In this talk, I will show how we use the power of ElasticSearch to create a personalized NewsFeed experience at scale. Find out how you can utilize ElasticSearch to create production grade ML capabilities such as recommender systems, personalized feeds, text classification and even personalized search! in a way developers can understand.

The WalkMe product development started 7 years ago by two developers in an apartment. Fast forward to the present and our R&D team has more than 150 people. It has been a roller coaster ride with many ups and downs. In my presentation I will tell the WalkMe engineering story and highlight the strategic decisions we made along the way. I hope my presentation would be interesting, fun, educational and inspiring.

Scoruby - Ruby scoring API for PMML files. Scoruby is a ruby gem that loads statistical models, gets their input, runs them, and returns the corresponding output. The gem loads its models from XML files in PMML format, which can be generated from different research environments among them R and Python open source packages. Scoruby implements the models scoring algorithms with data from the PMML files. We currently support Decision Trees, Random Forest and Gradient Boosted Models, and plan on keep adding models as we go.

Types declarations that are less common used. Brief description of each mechanism, example how can it be used and at the end some best practices how to use the typing system. - Intersection Types - Union Types - Type Guards - Nullable types - Never type - Interfaces vs. Type Aliases - Type Analysis - Mapped types - Pick or Partial etc - Generic type

Microservices development environment becomes more and more popular in cloud-based companies in order to support better CI/CD methodologies. I would like to show a case study which leads to best practices of how do we manage CI/CD for 200 microservices based both on Docker/Kubernetes and Puppet under production environments and be able to control them all using various of tools, internal developments and technologies.

In the last year I've being doing Open Source consulting for a various of companies, ranging from start ups to enterprise size. The talk would go over the common approaches towards Open Source in such companies, basic mistakes and commons misconceptions by developers and management.

Well-written code reads like a story, with tests as the story teller. How can we become better writers? In this talk we'll revisit software development and our daily struggles from this perspective. When do clean coding practices help us tell the story? When is it worth refactoring for clarity? How do we use tests to help the reader? Finally, we'll talk about presenting our writing to our readers for the first time, in code reviews. How can we give the reviewers right context? And how can we get the most out of the review? I hope you'll leave this talk thinking about code readability differently, writing better code, better tests and getting more out of reviews.

The Software Architect has a tough job. He has to design an architecture that will result in a fast, secure, reliable and easy to maintain system. During my 15 years as an Architect I've worked on hundreds systems, and with many other Architects, and I've come to realize there are some common mistakes Software Architects do, which result in their glorious architecture becoming a catastrophic failure. These mistakes, surprisingly, has nothing to do with technology or architectural patterns. They boil down to behavior, relationships, accountability and more. In this session we'll review these mistakes, suggest ways to avoid them, and use some real life stories to demonstrate their impact.

"You want to put the fire out first and then worry about the fire code" Ben Bernanke, Chairman of the Federal Reserve 2006-2014 What do you do when you have a piece of code that is on fire? Rollout.io’s CTO Eyal Keren will take the audience through four days of a crisis. He will cover the following: - Slowness, complaints, alerts - Impact on customers - Identifying the root cause - Understanding the right solution - "Put the fire out first and then worry about the fire code" Driven Solution - Using Rollout feature flags for traffic redirects - Deploying the usage of a queue service - Gradually rolling out performance optimization - Cleaning up after

The computation of large systems' atomistic dynamics is required in fields such as biochemistry, electrochemistry and many others. Fully quantum molecular dynamics is a powerful tool, but can have a high computational cost. An approach that was developed in the last decade is to use ML algorithms to build on the fly computationally cheap predictors for the energy, forces, and other physical properties. This approach enables the performance of calculations with an accuracy that is close enough to fully quantum molecular dynamics but with running speeds that are more than 100 times faster. We describe and analyze the construction and use of a DNN based model for the forces in solids.

This talk explains the transition process Logz.io R&D team underwent to move to Continuous Deployment using Kubernetes - existing challenges, the reasons Kubernetes was chosen for Docker orchestration, the implementation process, and the cultural change needed for making the shift. I will also showcase our opensource solution for deploying on top of Kubernetes - Apollo, and explain the reason we choose to develop it.

Processing data at scale usually involves struggling with performance, strict SLA, limited hardware capabilities and more.After struggling with Spark SQL query run-time I found the felon! In this lecture,I would like to share with you the change in perspective and process we had to go through in order to find the felon (and the solution!).Today in the world of Big Data and Spark we are processing high volume transactions.Catalyst is the Spark SQL query optimizer and in this talk, we will reveal how you can fully utilize Catalyst optimization power in order to make queries run as fast as possible,by pushing down actions and avoiding UDFs as much as possible,while still maximizing performance

When you _graduate_ into being a team leader or any other kind of manager you are (if you're lucky) granted some time to learn how to work with your employees. Communication, work processes, expectations and motivation. Issues passed on to you by your peers, managers and external consultants and coaches . This layer, however, is at best 10-20% of the work force (depending on how flat you've been able to keep your organization) . What about the rest of us?! In this talk, we will go over a few of the basic skills and tools no one tells you about which you can use when you need to manage your managers...cause at the end of the day, they're human too...

We will discuss what GraphQL is, what problems it solves, and why it's gaining mass adoption so rapidly. We will talk about how GraphQL solves many of today's common developer problems and improves developer patterns and efficiency. Specifically, we will discuss how: 1) Why GraphQL enables a new engineer to learn how to use your API in 5 minutes 2 How GraphQL makes your network transactions more efficient. 3) How GraphQL enforces a strongly typed schema, making it easier for your developers to bridge the gap between the front and back end. 4) Schema Stitching, how GraphQL enables us to compose GraphQL APIs by combining several GQL APIS from different sources

Today we try to understand our users’ behavior mainly by BI events. However, even with the perfect BI event system we still get the macro, not the micro. Sometimes watching a user’s session in real time could answer a lot of questions, such as how to increase the conversion rate, understand UX problems and much more. There are many tools (i.e fullstory, hotjar, insigtech, etc.) that give us the option to solve these problems in a kind of a magic way, yet is it real MAGIC? In my talk, I simplify the way you can mirror your user’s session and provide you with a simple and fast solution, in less than an hour!