Orhan Tuncer
Amsterdam, Noord-Holland, Nederland
492 volgers
494 connecties
Ervaring
-
-
-
-
-
-
-
-
-
Opleiding
Talen
-
English
Volledige professionele vaardigheid
-
Turkish
Moedertaal of tweetalig
Overige vergelijkbare profielen
Meer bijdragen onderzoeken
-
Yuri Derevianko
Once I was passing technical interview for C# developer position, and interviewer asked me "How you can interact with GC from code to collect particular object?" I answered it is not possible to collect individual object and there is no way to instruct GC to do it — all you can do is to ask GC at some point to do generational collection when the whole set of unreferenced objects is collected. The interviewer then asked: "Some interface may be?" — and I realized that he was talking about IDisposable. The thing is that IDisposable is NOT for garbage collection. There is subtle relation between an object being collected and Dispose method on that object being called, but it is when GC calls that code during collection, not the opposite. Good video on this subject from Shawn Wildermuth https://lnkd.in/e9aVVfRx
-
Fabian Gosebrink
And here we are: A Typescript Advanced Course ready to be booked 🚀🚀🚀 ✅ Basics: Overview of TypeScript's basic abilities and limitations. ✅ Type System: How TypeScript's type system works. ✅ Advanced Types: Create flexible types with Union and Intersection. ✅ Utility Types: Use common type transformations. ✅ Never: Represent impossible scenarios in TypeScript. ✅ Generics: Deep dive into constraints and type recursion. ✅ Literals & Template Literals: Use specific types for precise narrowing. ✅ Mapped Types: Create types based on existing ones. ✅ Type Guards: Securely recognize and narrow down types. ✅ Branded Types: Advanced techniques for complex patterns. https://lnkd.in/e5Up8VAj
-
Paras Jaiswal
🚀 Microservice made easy Why AutoMapper and MediatR Matter. AutoMapper: Imagine you’re moving houses. You’ve got furniture in your old place (say, a Customer object), and you need to arrange it nicely in your new place (a CustomerDto). AutoMapper is like your magical moving service. It takes care of copying your sofa, TV, and plants from one place to another without you lifting a finger. In code terms, it helps transform data between different parts of your microservices—like converting database records into neat little packages that your APIs can deliver. MediatR: Think of MediatR as the communication hub at a bustling party. You’ve got guests (commands, queries, and responses) who want things done. Instead of everyone shouting across the room, they talk to the mediator. The mediator then finds the right person (handler) to handle each request. So, when you need to order a pizza (send a command), you don’t directly call the pizza place—you tell the mediator, and it sorts things out. MediatR keeps your microservices organized, making sure everyone talks politely and doesn’t step on each other’s toes. #dotnet #MicroservicesMadeEasy #AutomapperMagic #EfficientCommunication #MediatRMastermind
-
Tommaso Allevi
What happens if your front end needs better local state management? The user will see a loading while the same service tries to respond to the equal 6 parallel requests. Also, the browser limits parallel requests to the exact origin. It is just an example from NeN. NB: The time for the response increases a lot, probably because of the logic behind the current account leverage on a lock, so the following request has to wait for the previous one to complete. #nen #frontend #statemanagement #lock #parallel
-
Dariusz Kalbarczyk
🔹 Pragmatic Angular Testing Workshop 🔹 Join Younes Jaaidi for an in-depth, hands-on master class on Angular Testing. This workshop is designed to simplify front-end testing complexities and help you build a maintainable testing strategy. 📅 Date: November 5, 2024 📍 Location: ADN Conference Center, Warsaw ⏰ Time: 10:00 - 17:00 (available both in-person & online) Workshop Highlights: 👉 TDD Approach – Implement Angular tests with Test-Driven Development, ensuring strong code quality from the start. 👉 Readable & Maintainable Tests – Develop tests that are easy to read, maintain, and that lower long-term testing costs. 👉 Testing Roles – Understand when to use dummies, stubs, spies, mocks, and fakes effectively. 👉 Component Testing Levels – Distinguish between isolated, shallow, and integration testing, choosing the best approach for each case. 👉 Testing Tools – Explore tools like Jest, Cypress, and Playwright, including visual regression testing for efficient workflows. 👉 Pragmatic Testing Strategy – Build a testing strategy that adds value, making refactoring and deployment more efficient. 🔗 https://lnkd.in/dBWzvWJ Enhance your team’s confidence and efficiency with practical testing techniques that guarantee quality and maintainability across your Angular projects!
-
Kiran Bagul
RabbitMQ vs. Kafka: In the world of microservices, efficient communication is key. But when it comes to choosing the right messaging champion, two contenders stand out: RabbitMQ and Kafka. Both are powerhouses, but their strengths differ. RabbitMQ: The Agile Champion RabbitMQ is a message broker, excelling in complex routing and reliable delivery for smaller datasets. Its AMQP protocol ensures clear communication, and its flexible plugins allow customization. Ideal for transactional tasks like order confirmations, user actions, and internal messaging within your application. Kafka: The Scalable Streamer Kafka is a distributed streaming platform, built for real-time data processing of massive datasets. Its append-only log allows efficient access to historical data, and its horizontal scaling ensures smooth handling of high traffic. Ideal for real-time data processing, event-driven architectures, and processing large datasets for insights. Who is best in scenarios - - Message volume: If you deal with massive data streams, Kafka should get priority. - Message complexity: For complex routing and diverse message types, RabbitMQ shines. - Scalability needs: If you anticipate rapid growth, Kafka's horizontal scaling is unbeatable. - Real-time requirements: For real-time data processing, Kafka delivers. - Ease of use: For simpler deployments, RabbitMQ's lighter weight might be better. Feel free to share your views.
-
Mohammad Ayash
🚀 Excited to share insights on Dependency Injection in .NET Core! 🚀 In the world of software development, Dependency Injection (DI) plays a pivotal role in enhancing modularity, maintainability, and testability of applications. And in the realm of .NET Core, it's a powerful tool that simplifies managing dependencies and promotes cleaner, more flexible code. 🔍 What is Dependency Injection? Dependency Injection is a design pattern where dependencies are injected into a class rather than the class creating them itself. This promotes loose coupling between components, making code more modular and easier to maintain. 💡 Why Dependency Injection in .NET Core? 1️⃣ Modularity: .NET Core's built-in DI container allows you to register and resolve dependencies effortlessly. This fosters modular architecture, enabling easier updates and scalability. 2️⃣ Testability: With DI, you can easily substitute dependencies with mock objects during testing, facilitating unit testing and ensuring the reliability of your codebase. 3️⃣ Flexibility: .NET Core's DI container supports various lifetimes for registered services, such as transient, scoped, and singleton, offering flexibility in managing object instances. 4️⃣ Decoupling: By injecting dependencies rather than hardcoding them, you decouple components, making your codebase more maintainable and adaptable to changes. 🛠️ How to Use Dependency Injection in .NET Core? 1️⃣ Register Services: Start by registering your services and their implementations with the DI container in the ConfigureServices method of the Startup class. 2️⃣ Inject Dependencies: Inject dependencies into your classes using constructor injection, property injection, or method injection, depending on your requirements. 3️⃣ Leverage Scopes: Understand the difference between transient, scoped, and singleton lifetimes and choose the appropriate one for each service registration to manage object instances efficiently. 4️⃣ Unit Testing: Utilize DI to inject mock dependencies into your unit tests, allowing you to isolate and test individual components of your application. Let's embrace the power of Dependency Injection in .NET Core to build robust, maintainable, and scalable applications! 💪 #dotnetcore #dependencyinjection #softwaredevelopment #modularity #testability
-
Thiago Souza
As a Java developer, integrating robust messaging solutions like RabbitMQ with Spring Boot can significantly enhance the scalability and resilience of your applications. RabbitMQ, a powerful message broker, provides efficient message queuing and delivery mechanisms, making it an ideal choice for distributed systems. When combined with Spring Boot, RabbitMQ offers seamless integration and simplified configuration. Spring Boot's auto-configuration capabilities reduce the boilerplate code, allowing developers to focus on building business logic rather than managing infrastructure. By leveraging Spring AMQP, you can easily connect to RabbitMQ, define queues, exchanges, and bindings, and implement message listeners with minimal effort. One of the key benefits of using RabbitMQ with Spring Boot is the ability to decouple your services. This decoupling promotes microservices architecture, where each service can independently produce and consume messages, enhancing modularity and maintainability. Furthermore, RabbitMQ's support for various messaging patterns, such as publish/subscribe and work queues, ensures that your application can handle different communication scenarios efficiently. In addition to improved decoupling, RabbitMQ provides reliable message delivery guarantees. With features like message acknowledgments, persistence, and dead-letter exchanges, you can ensure that no messages are lost, even in the face of system failures. Spring Boot's integration with RabbitMQ simplifies the configuration of these features, making it easier to build resilient and fault-tolerant applications. Moreover, RabbitMQ's extensibility allows it to fit into diverse environments. Whether you're deploying on-premises or in the cloud, RabbitMQ offers plugins and extensions that cater to various use cases, including monitoring, security, and federation. Spring Boot, with its cloud-native capabilities, complements this by enabling seamless deployment and scaling of RabbitMQ-based applications in modern cloud infrastructures. In summary, combining RabbitMQ with Spring Boot provides a powerful and flexible messaging solution that enhances the scalability, reliability, and maintainability of your Java applications. By leveraging the strengths of both technologies, you can build robust, decoupled systems capable of handling complex communication patterns and ensuring reliable message delivery. #Java #SpringBoot #RabbitMQ #Microservices #Messaging #Scalability #Resilience #CloudComputing #SoftwareDevelopment #DistributedSystems
4 commentaren -
Francesco Colaianni
🚀 Exciting News! 🚀 With recent updates in Blazor templates, the option for a WebAssembly hosted solution is no longer included by default in .NET8. Many developers rely on this setup for building full-stack Blazor apps with a shared backend and that’s why I decided to create a template extension that brings it back. This extension contains: - An ASP.NET Core Web API - A Blazor WebAssembly project - A shared class library project It’s designed to streamline the process of scaffolding your projects, saving time and simplifying development. Check it out here: https://lnkd.in/deJgsYfy 💻 Happy coding! #VisualStudio #Blazor #DeveloperTools #Productivity #Extensions #Template #FullStackDevelopment
-
Ahmed Tarek Hasan
🧑💻 Memory Management In .NET 🤷♂️ If you want to know all about memory management in .NET, read this article. If you like the content, you can: ⭐ Share/Repost for others to benefit from it ⭐ Follow for more similar content 📖 https://lnkd.in/eGj-VZU6 📭 https://lnkd.in/eaJKUgEQ #dotnet #softwareengineering #softwarearchitecture #softwaredesign #bestpractices #memory #developmentsimplyput
2 commentaren -
alireza Oliyaie
Understanding Deep Copy in C# In C#, managing object instances and their data effectively is crucial for building robust applications. One common concept developers encounter is the distinction between shallow copy and deep copy. In this article, we will explore what deep copy is, how it differs from shallow copy, and how to implement it in C#. What is Shallow Copy? Before diving into deep copy, it’s essential to understand shallow copy. A shallow copy creates a new object that is a copy of the original object, but it copies only the references to the nested objects. Consequently, changes made to the nested objects in the copied instance will reflect in the original instance since both references point to the same memory location. Example of Shallow Copy public class Address { public string Street { get; set; } } public class Person { public string Name { get; set; } public Address Address { get; set; } } Person original = new Person { Name = "John", Address = new Address { Street = "123 Main St" } }; Person shallowCopy = original; // This is a shallow copy shallowCopy.Address.Street = "456 Elm St"; // Changes the street in both instances Console.WriteLine(original.Address.Street); // Output: 456 Elm St What is Deep Copy? Deep copy, on the other hand, creates a new object along with copies of all the nested objects. This means that modifications to the nested objects in the copied instance will not affect the original instance, as they reside in different memory locations. Example of Deep Copy To implement deep copy, you can use several methods, such as serialization or manually cloning objects. Here’s a simple manual implementation: public class Address { public string Street { get; set; } } public class Person { public string Name { get; set; } public Address Address { get; set; } // Method to create a deep copy public Person DeepCopy() { Person copy = (Person)this.MemberwiseClone(); // Shallow copy copy.Address = new Address { Street = this.Address.Street }; // Deep copy of Address return copy; } } Person original = new Person { Name = "John", Address = new Address { Street = "123 Main St" } }; Person deepCopy = original.DeepCopy(); deepCopy.Address.Street = "456 Elm St"; // Changes only the copied instance Console.WriteLine(original.Address.Street); // Output: 123 Main St Using Serialization for Deep Copy An alternative method to perform deep copy is through serialization. This approach is particularly useful for complex objects. You can serialize the object to a memory stream and then deserialize it back to create a new instance.
Anderen hebben Orhan Tuncer genoemd
-
Orhan Tuncer
-
Orhan Tunçer
Mechanical Engineer
-
orhan tunçer
--
-
Orhan Murat Tuncer
Senior Year Software Engineering Student
22 anderen door wie Orhan Tuncer is genoemd, gebruiken LinkedIn
Bekijk anderen die Orhan Tuncer heten