top of page
OUR SPEAKERS
Share on:
Yarden Laifenfeld is a Software Engineer at Rookout. With a deep background in C and embedded Linux environments, you can find her in the office jumping between 6 different programming languages a day. When she’s not busy developing new features and helping out clients, she loves learning about new technology, creating iOS apps and making everything she can automated.
Yarden Laifenfeld
Software Engineer
English, Hebrew
Languages:
Location:
Tel Aviv, Israel
Can also give an online talk/webinar
Paid only. Contact speaker for pricing!
MY TALKS
Debugging, the Developer Way
Software Engineering, Professional Development, Frontend, Backend, Mobile
As developers, we have many skills we use and constantly improve when writing code. But when it comes to debugging, most of us go for a primarily research-based approach, asking ourselves questions like “how did this bug happen?” and “what in the code is causing this behavior?“.
By taking this approach and asking these questions, we’re treating our codebase like it’s a mystery and the bug like it’s a malicious piece of code injected by some evil entity (when, let’s admit, that’s usually not the case). This means that we are leaving the skills we pride ourselves on having as developers - such as logical thinking, designing code and problem-solving - behind. This causes the debugging process to be that much harder and more time-consuming than it has to be.
In this talk, I will present a different approach to debugging, one that takes advantage of our programming abilities and utilizes them to find bugs faster all while improving our software development and design skills.
Understanding Java's Debugging Internals
Software Engineering, Backend, Mobile
Knowing your enemies is as important as knowing your friends. Understanding your debugger is a little of both. Have you ever wondered how Java debugging looks on the inside? On our journey to building a Java production-grade debugger, we learned a lot about its internals, quirks and more.
During this session, we’ll share how debugging actually works in Java. We’ll discuss Java bytecode instrumentation, giving multiple examples to how this can be accomplished, and dive deep into utilizing the Java Agent API to create a debugger. But this talk is about more than just debuggers - it’s about changing your code as it is running, and understanding the JVM enough to manipulate it without disrupting it.
From OOP to Go
Software Engineering, Frontend, Backend, Mobile
I’m guessing that Go wasn’t your first programming language. When you started to learn Go you probably thought to yourself that structs are like classes, and that embedding a struct is like inheriting from a class - I know that I did. Now, while that’s a good way to start learning Go’s concepts, using embedded structs as inheritance in Go code is problematic and may lead to design flaws, and, worse, to buggy code.
On the other hand, there’s a reason almost all high level programming languages have inheritance - it’s a good way to reuse code and to extend the behavior of external libraries. So, what’s the right way to reach these goals in Go?
In order to answer this question, we need to understand the difference between a struct in Go and a class in a high level language. This talk will focus on Go’s relationship with inheritance, but along the way we’ll also discuss our process of thought when designing a Go program, from what structs we create, to which interfaces they implement and
Ruby & JVM: A (JRuby) Love Story
Software Engineering, Backend, Mobile
When starting a new project, one of the first things we ask ourselves is what language we should use. This question doesn’t have an absolute answer, and we often find ourselves facing even more questions, such as: Do we want a language that is object oriented? Should we opt only for languages with garbage collectors? Is being able to interact directly with memory important to us? Does the language have popular and well maintained frameworks that match our specific needs? Do we care more about readability or performance?
If you’ve ever found yourself wanting to choose Ruby, but are hesitating because it’s interpreted and performance might suffer - or if you simply want to hear more about JRuby - this talk is for you.
In this talk I will dive into why you should - or shouldn’t - use JRuby in your upcoming projects. We’ll compare the language to Ruby and other JVM languages, discuss its limitations and restrictions, and even dive into how such a strange concoction of languages came to b
Go Stack: Should It Be Moving Like That?
Software Engineering, Professional Development, Backend
Let’s talk about Go’s stack!
Go’s runtime manages the stacks of all goroutines in a unique way. Each stack starts off small (2K!) and gets bigger and smaller as needed. If you’re wondering how that happens - this talk is for you!
Go Sync or Go Home: Advanced Concurrency Techniques for Better Go Programs
Software Engineering, Backend
Go is known for being fast and efficient, enabling developers to write concurrent programs with lightweight threads and easy-to-use API. In order to take advantage of goroutines and synchronize between them, you've probably used bits of the sync package. But to get the most out of Go's concurrency model, knowing the basics isn't enough. In this talk we will dive into the standard sync package and the x/sync package, getting to know lesser-known features that can be used to improve your code. We will discuss several use cases for each synchronization pattern, and how to take your existing code and make it more robust by using these features.
Debugging, the Developer Way
Completed
true
Visible
true
Order
6
Understanding Java's Debugging Internals
Completed
true
Visible
true
Order
5
From OOP to Go
Completed
true
Visible
true
Order
6
Ruby & JVM: A (JRuby) Love Story
Completed
true
Visible
true
Order
6
Go Stack: Should It Be Moving Like That?
Completed
true
Visible
true
Order
3
Go Sync or Go Home: Advanced Concurrency Techniques for Better Go Programs
Completed
true
Visible
true
Order
4
bottom of page