Tamir Dresher
Cloud Division Leader, CodeValue
Tel Aviv, Israel
Tamir Dresher is a software architect with over 10 years of experience of developing, consulting and teaching large scalable distributed systems. Tamir is a System Architect at Payoneer and teach Software Engineering at the Ruppin Academic Center. Tamir is a prominent member of the Israeli developer community where he leads the Israeli chapter of IASA, the Software Architects Forum by IsraelClouds and the online technology show “Telescopim”. He is the author of the books “Rx.NET in Action" and "Hands-On Full-Stack Web Development with ASP.NET Core" and speaks frequently at conferences and meetup. He blogs at www.tamirdresher.com and you can reach out to him via Twitter @tamir_dresher.
Links
Area of Expertise
Topics
Messaging patterns from the trenches
To achieve the scale we need in our systems, we rely heavily on our messaging platform.
Over the years we have grown our platform and added support for various requirements. Along the way we discovered patterns that helped us deal with recurring issues involving messaging in a multi-tenant SaaS environment.
In this presentation you'll learn about patterns for balancing load, avoiding messaging conflicts, reducing processing latency, isolating noise and more.
Asynchronous streams in C# with System.Linq.Async and System.Interactive.Async
Asynchronous processing of work is in the heart of any scalable system and interactive applications.
Over the years, the industry developed many techniques, frameworks, and patterns to make it easier for developers to add the asynchronicity to their code and .NET was no exception.
However, most of the innovation concentrated on a single work item and the concept of streams of data was given little attention.
With the new addition of IAsyncEnumerable and the System.Linq.Async and System.Interactive.Async libraries things have finally changed.
In this lecture you will learn what asynchronous streams mean in C# and how you can leverage them to build complex asynchronous pipelines inside your .NET applications.
Demystifying the Core of .NET Core
.NET Core has revolutionized the way we build applications. Today, you can write .NET code once and run it anywhere using the tools, practices, and techniques that .NET community known and loved for years. In this session, you'll learn about architecture of .NET Core and .NET Standard which allows it to run on any platform like Linux, OSX and windows. And you will explore how to integrate the different utilities, libraries and concepts to maximize your .NET skills in the new world of cross-platform .NET.
Breaking the Monolith with Azure Service Fabric
Breaking your application to microservices brings many promises, but nobody talks about the new challenges it brings: Discovery, Fault tolerance, Deployment, Upgrades and so on.
Azure Service Fabric is a Service Orchestrator that allows you to create a microservices architecture and provide all the necessary utilities and services to solve the challenges of this new world.
In this session you’ll learn to create a full microservices system, no matter what is your technology stack or cloud provider, with scalability, availability, maintainability in mind – all thanks to Azure Service Fabric
.NET Debugging tricks you wish you knew
Do you know what developers do most of their day (except for surfing the internet)?
Writing code? WRONG!
They are debugging. The debugger is a powerful tool, but in this talk you'll learn tricks that will help find bugs in half the time and with less frustration. Because a happy developer is a productive developer.
I'll show you to use tools that will point to you to right direction and features didn't know that are even there, for both development time debugging and post-mortem production analysis.
From Zero to the Actor Model
The Actor Model that was introduced in 1973 looks at the world as a set of actors that holds a state and a behavior.
This idea is very similar to OOP that we all know and love, but actors are not limited to a single machine.
Instead, actors can be distributed to multiple processes and machine, and create a network of processors that encapsulate the problem-domain.
This model has significant implications on the way we can write large scale distributed systems and can make very hard problems, very easy to solve.
Creating a responsive application using Reactive Extensions
Creating a responsive application using Reactive Extensions
-------------------------------------------------------------
Working with asynchronous services has always been a desirable approach and a necessity when creating a responsive, Connected, Data intensive application.
Today, when every application needs to work with sources like Facebook, Twitter, device sensors and Cloud Services, this task become harder and harder.
In this session we will see how can ease our development when dealing with such tasks using the power of RX.
We will see how to take a very common scenario in our modern application and turn it into Reactive Programming Style and making our application Responsive and easy
The Zen of Serverless with Azure Functions
Azure Functions and the trend of serverless architecture has opened the door to a new and exciting world of opportunities, which allow developers to create cloud applications easily. Instead of wasting your money on wasteful CPU cycles and hardware resources by underutilizing them, you pay only for what you consume.
In this session you'll learn what is serverless architectures and how to implement it with Azure Functions, how to get started developing and running serverless code with the industry best-practices, and which pitfalls to avoid.
Cloud Patterns
Cloud computing provides amazing capabilities for the modern application,
But there are many pitfalls to be aware of – scalability, resiliency, elasticity, security and more.
In this session we will explore the differences between cloud programming to “regular” programming to understand what are the things we should consider with designing and developing out application. We will explore different patterns that we should you use for different scenarios such as dealing with transient errors using the different retry patterns. We will look at architectural patterns such as cloud messaging patterns and Cache-Aside and their effect on the total application structure.
Testing Rx code and abstracting time and concurrency
Rx helps us solve many complex problems, such as combining different streams and reacting to events that involve timing aspects.
However, solving those problems with code is not really "done" unless you can validate and assure your results.
In this session you'll learn the Rx.NET testing utilities and patterns that makes testing Rx code not only easy but also a lot of fun
From Zero to the Actor Model
The Actor Model that was introduced in 1973 looks at the world as a set of actors that holds a state and a behavior.
This idea is very similar to OOP that we all know and love, but actors are not limited to a single machine.
Instead, actors can be distributed to multiple processes and machine, and create a network of processors that encapsulate the problem-domain.
This model has significant implications on the way we can write large scale distributed systems and can make very hard problems, very easy to solve.
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top