Gil Zilberfeld

@[email protected]
46 Followers
48 Following
56 Posts
Agile development and testing consultant and trainer
Twitterhttps://twitter.com/gil_zilberfeld
LinkedInhttps://www.linkedin.com/in/gilzilberfeld/
Githubhttps://github.com/gilzilberfeld/
Sitehttps://www.everydayunittesting.com/
Gil ZilberfeldJan 31, 2023
Most people think that 2+3=5.
Think? They know that. So much, that if they had code that does it, they wouldn't bother with a test.
But that's because they know how the code is written. If they didn't, would they still not bother?
Check it out.
https://www.everydayunittesting.com/2022/08/black-and-white.html #software
Black and White | Everyday Unit Testing

Black box, white box. Does our choice of perspective matter? We've landed this function declaration: public int add(int a, int b); We're told that it adds two integer numbers. How should we test it? Let's see, we can check that sending 2 and 3 returns 5. We can also send 3 and 4, and expect

Everyday Unit Testing | By Gil Zilberfeld
Gil ZilberfeldJan 26, 2023

Going live in 10 minutes.

RT @[email protected]

Just a reminder. I'm going to refactor a microservice to patterns today.
Register to the webinar:
https://us02web.zoom.us/webinar/register/3816527847113/WN_sQffXtz9QremPmJ_zveAAA

#software #api #apis #microservices #microservice #webinar #automatedtesting #unittesting #java #junit #python #csharp #javascript #apitesting

🐦🔗: https://twitter.com/gil_zilberfeld/status/1618548045989416960

Welcome! You are invited to join a webinar: Microservices - Refactoring APIs to Patterns. After registering, you will receive a confirmation email about joining the webinar.

"Microservices allow for quick development and delivery. But if the code is, let's say, of the legacy persuasion, the development quickly slows down. Refactoring to rescue. And this time, it's not just about well-factored, readable code (although we really like it). We'll use common architectural and design patterns that make the code modular, extensible and testable. In this webinar, I'll take some (very ugly) microservice API code and refactor it. We'll make sure the domain logic is separated from the infrastructure code, and that the domain logic is unit testable. We'll discuss and use common design patterns (factories, repositories, etc.), and explain how using them helps keep the architecture flexible and maintainable. Once the code is factored, we'll see what additional tests we can write - and where they help us. Microservices code should be modular, cohesive and testable. If it's not - refactoring according to architecture and design patterns is the best way to get there."

Zoom
Gil ZilberfeldJan 26, 2023

Just a reminder. I'm going to refactor a microservice to patterns today.
Register to the webinar:
https://us02web.zoom.us/webinar/register/3816527847113/WN_sQffXtz9QremPmJ_zveAAA

#software #api #apis #microservices #microservice #webinar #automatedtesting #unittesting #java #junit #python #csharp #javascript #apitesting

Welcome! You are invited to join a webinar: Microservices - Refactoring APIs to Patterns. After registering, you will receive a confirmation email about joining the webinar.

"Microservices allow for quick development and delivery. But if the code is, let's say, of the legacy persuasion, the development quickly slows down. Refactoring to rescue. And this time, it's not just about well-factored, readable code (although we really like it). We'll use common architectural and design patterns that make the code modular, extensible and testable. In this webinar, I'll take some (very ugly) microservice API code and refactor it. We'll make sure the domain logic is separated from the infrastructure code, and that the domain logic is unit testable. We'll discuss and use common design patterns (factories, repositories, etc.), and explain how using them helps keep the architecture flexible and maintainable. Once the code is factored, we'll see what additional tests we can write - and where they help us. Microservices code should be modular, cohesive and testable. If it's not - refactoring according to architecture and design patterns is the best way to get there."

Zoom
Gil ZilberfeldJan 25, 2023

Webinar tomorrow!

"Microservices: Refactoring to patterns". With very big code and very small pasta.

Register here:
https://us02web.zoom.us/webinar/register/3816527847113/WN_sQffXtz9QremPmJ_zveAAA

Please RT!

Welcome! You are invited to join a webinar: Microservices - Refactoring APIs to Patterns. After registering, you will receive a confirmation email about joining the webinar.

"Microservices allow for quick development and delivery. But if the code is, let's say, of the legacy persuasion, the development quickly slows down. Refactoring to rescue. And this time, it's not just about well-factored, readable code (although we really like it). We'll use common architectural and design patterns that make the code modular, extensible and testable. In this webinar, I'll take some (very ugly) microservice API code and refactor it. We'll make sure the domain logic is separated from the infrastructure code, and that the domain logic is unit testable. We'll discuss and use common design patterns (factories, repositories, etc.), and explain how using them helps keep the architecture flexible and maintainable. Once the code is factored, we'll see what additional tests we can write - and where they help us. Microservices code should be modular, cohesive and testable. If it's not - refactoring according to architecture and design patterns is the best way to get there."

Zoom
Gil ZilberfeldJan 24, 2023
What makes microservices testable? Glad you asked. I got a webinar for it. In two days.
Register her:
https://us02web.zoom.us/webinar/register/3816527847113/WN_sQffXtz9QremPmJ_zveAAA
Welcome! You are invited to join a webinar: Microservices - Refactoring APIs to Patterns. After registering, you will receive a confirmation email about joining the webinar.

"Microservices allow for quick development and delivery. But if the code is, let's say, of the legacy persuasion, the development quickly slows down. Refactoring to rescue. And this time, it's not just about well-factored, readable code (although we really like it). We'll use common architectural and design patterns that make the code modular, extensible and testable. In this webinar, I'll take some (very ugly) microservice API code and refactor it. We'll make sure the domain logic is separated from the infrastructure code, and that the domain logic is unit testable. We'll discuss and use common design patterns (factories, repositories, etc.), and explain how using them helps keep the architecture flexible and maintainable. Once the code is factored, we'll see what additional tests we can write - and where they help us. Microservices code should be modular, cohesive and testable. If it's not - refactoring according to architecture and design patterns is the best way to get there."

Zoom
Gil ZilberfeldJan 19, 2023

Adapters, factories and repositories. Maybe a few more.

Want to know more about how code patterns impact clean microservices? There's a webinar for that!
Register here:
https://us02web.zoom.us/webinar/register/3816527847113/WN_sQffXtz9QremPmJ_zveAAA

#api #microservices #Aps #REST #java #python #csharp #javascript

Welcome! You are invited to join a webinar: Microservices - Refactoring APIs to Patterns. After registering, you will receive a confirmation email about joining the webinar.

"Microservices allow for quick development and delivery. But if the code is, let's say, of the legacy persuasion, the development quickly slows down. Refactoring to rescue. And this time, it's not just about well-factored, readable code (although we really like it). We'll use common architectural and design patterns that make the code modular, extensible and testable. In this webinar, I'll take some (very ugly) microservice API code and refactor it. We'll make sure the domain logic is separated from the infrastructure code, and that the domain logic is unit testable. We'll discuss and use common design patterns (factories, repositories, etc.), and explain how using them helps keep the architecture flexible and maintainable. Once the code is factored, we'll see what additional tests we can write - and where they help us. Microservices code should be modular, cohesive and testable. If it's not - refactoring according to architecture and design patterns is the best way to get there."

Zoom
Gil ZilberfeldJan 18, 2023

My next webinar is next week. "Refactoring microservices to patterns".
For messy microservices only :)
Register here:

https://us02web.zoom.us/webinar/register/3816527847113/WN_sQffXtz9QremPmJ_zveAAA

Welcome! You are invited to join a webinar: Microservices - Refactoring APIs to Patterns. After registering, you will receive a confirmation email about joining the webinar.

"Microservices allow for quick development and delivery. But if the code is, let's say, of the legacy persuasion, the development quickly slows down. Refactoring to rescue. And this time, it's not just about well-factored, readable code (although we really like it). We'll use common architectural and design patterns that make the code modular, extensible and testable. In this webinar, I'll take some (very ugly) microservice API code and refactor it. We'll make sure the domain logic is separated from the infrastructure code, and that the domain logic is unit testable. We'll discuss and use common design patterns (factories, repositories, etc.), and explain how using them helps keep the architecture flexible and maintainable. Once the code is factored, we'll see what additional tests we can write - and where they help us. Microservices code should be modular, cohesive and testable. If it's not - refactoring according to architecture and design patterns is the best way to get there."

Zoom
Gil ZilberfeldJan 17, 2023
We do refactoring everyday.
Or do we?
But how do we know, we REALLY didn't change the functionality?
My webinar covers these questions, even before touching on the "how" part.
Check out the webinar recording:
https://www.everydayunittesting.com/2022/09/refactoring-without-a-net-webinar-recording.html
#cleancode #java #python #csharp #javascript
Refactoring Without A Net – Webinar Recording | Everyday Unit Testing

What exactly is refactoring? Is it just changing code? What does "not changing functionality" really means? Well, you've come to the right place. I've got just the webinar for you. And not only that, I'm going to show you how to refactor, even when you don't have tests. If you want to go deep, check

Everyday Unit Testing | By Gil Zilberfeld
Gil ZilberfeldJan 12, 2023

The repository pattern comes from Domain Driven Design. It has a benefits to clean code.
Read my post here:
https://www.linkedin.com/feed/update/urn:li:activity:7019302647463567361

#software #api #apis #microservices #microservice #webinar #testing #automatedtesting #unittesting #java #junit #python #csharp #javascript

Sign Up | LinkedIn

500 million+ members | Manage your professional identity. Build and engage with your professional network. Access knowledge, insights and opportunities.

Gil ZilberfeldJan 10, 2023

How much time and effort goes into test automation maintenance? Automation test suites should be helping us. How come we end up working for them?

Check out my blog post.

https://www.everydayunittesting.com/2022/10/is-it-worth-it.html

#testing #automatedtesting #apitesting, #testability, #rest, #api, #apis

Is Test Automation Worth It? | Everyday Unit Testing

So here's a silly question: Why do we need test automation? I'm going somewhere with this, work with me. Testing and test automation are tools to reach a goal. The goal is to have a picture of quality of our system, or our product. There's a lot going into this picture, including the level of

Everyday Unit Testing | By Gil Zilberfeld