- Exploring Kafka Steams Partitioning, Scaling, and Fault Tolerance – we’ll build a simple streaming app and inspect the contents of the repartition topic, RocksDB state store, and the Kafka internal changelog topic. https://vkontech.com/exploring-kafka-steams-partitioning-scaling-and-fault-tolerance/ 5 comments coding
- A blog post where we use Wireshark to trace the Kafka networking protocol. The client is a simple C# app interacting with a multi-broker Kafka cluster. https://vkontech.com/kafka-networking-via-wireshark/ 13 comments programming
- Running Containerized .NET Scheduled Tasks with AWS Fargate – Part 1 https://vkontech.com/running-containerized-net-scheduled-tasks-with-aws-fargate-part-1/ 4 comments csharp
- Running NodeJS Microservices in Kubernetes using AWS EKS & Travis CI, Part 3 – a demo project part of the Udacity “Cloud Developer” Nanodegree. In this post, you will see how to deploy the sample system to Kubernetes using AWS EKS. https://vkontech.com/running-nodejs-microservices-in-kubernetes-using-aws-eks-travis-ci-part-3/ 3 comments node
- Running NodeJS Microservices in Kubernetes using AWS EKS & Travis CI, Part 1 – a demo project part of the Udacity “Cloud Developer” Nanodegree. https://vkontech.com/running-nodejs-microservices-in-kubernetes-using-aws-eks-travis-ci-part-1/ 6 comments node
- Deploying your Node API to AWS using Elastic Beanstalk – a demo project part of the Udacity “Cloud Developer” Nanodegree. https://vkontech.com/deploying-your-node-api-to-aws-using-elastic-beanstalk-demo-project/ 2 comments node
- The Awaitable Pattern plays a vital role in the whole async/await workflow behind the scenes. The best way to understand how it works is to build your own awaitable type. Let’s see how! https://vkontech.com/exploring-the-async-await-state-machine-the-awaitable-pattern/ 10 comments dotnet
- What are Closures? How are they implemented in C#? How do they “capture” environment variables from different scopes? What are the side effects you weren’t aware of? Let’s get some practical intuition inspecting the IL code as a source of truth. https://vkontech.com/the-intuitive-guide-to-understanding-closures-in-c/ 3 comments dotnet
- [C#] Call stacks in async methods are fundamentally different compared to synchronous execution. This leads to pitfalls where seemingly reasonable refactoring can make a method “disappear” from the Stack Trace. Let’s see why and how. https://vkontech.com/exploring-the-async-await-state-machine-stack-traces-and-refactoring-pitfalls/ 47 comments programming
- Call stacks in async methods are fundamentally different compared to synchronous execution. This leads to pitfalls where seemingly reasonable refactoring can make a method “disappear” from the Stack Trace. Let’s see why and how. https://vkontech.com/exploring-the-async-await-state-machine-stack-traces-and-refactoring-pitfalls/ 4 comments dotnet
- The Awaitable Pattern plays a vital role in the whole async/await workflow behind the scenes. The best way to understand how it works is to build your own awaitable type. Let’s see how! https://vkontech.com/exploring-the-async-await-state-machine-the-awaitable-pattern/ 44 comments csharp
- Call stacks in async methods are fundamentally different compared to synchronous execution. This leads to pitfalls where seemingly reasonable refactoring can make a method “disappear” from the Stack Trace. Let’s see why and how. https://vkontech.com/exploring-the-async-await-state-machine-stack-traces-and-refactoring-pitfalls/ 8 comments csharp
- FP or OOP is not a binary choice. You can have a healthy mix of the two in your program. Whatever paradigm you select to be central to your design, there will be cases when the other style fits better. Let’s start exploring this in Part #4 of the Clash of Styles series https://vkontech.com/clash-of-styles-part-4-adding-support-for-rational-numbers-with-fp/ 25 comments csharp
- The FP vs. OOP choice can directly affect the extensibility of your program. What is “easy” to add in OOP is “hard” in FP and vice versa. How can that be presented in terms of the Open-Closed Principle? https://vkontech.com/clash-of-styles-part-3-extensibility-via-oop-and-fp/ 2 comments csharp
- An article on the internals of nested async/await calls. You’ll see a very detailed workflow diagram with all the execution steps. This also helps to understand precisely why and when we need to use ConfigureAwait(false) in our libraries. https://vkontech.com/exploring-the-async-await-state-machine-nested-async-calls-and-configureawaitfalse/ 7 comments csharp
- A Practical Intro to Covariance and Contravariance in C# https://vkontech.com/a-practical-intro-to-covariance-and-contravariance-in-c/ 3 comments csharp
- How do we "interpret" our requirements with a Functional Programming mindset? How does it encourage us to decompose our program in terms of Operations? How is that precisely the opposite of the OOP perspective? Learn about it in the second part of the "Clash of Styles" series. Examples in C# and F# https://vkontech.com/clash-of-styles-part-2-operations-matrix-via-fp/ 2 comments csharp
- “Programming Languages” Series on Coursera is IMO, one of the best classes on foundational programming language paradigms. I strongly recommend it. You’ll be writing your own mini interpreter in Racket. Here is a full course review. https://vkontech.com/course-review-programming-languages-series-on-coursera/ 57 comments programming
- The Synchronization Context is an abstraction that lets you run a piece of code asynchronously without thinking about the specifics of the current environment. How does it work, and when is it invoked as part of the async workflow? Let’s explore those topics! https://vkontech.com/exploring-the-async-await-state-machine-synchronization-context/ 15 comments csharp
- I wrote a series of articles describing the async/await State Machine produced by the C# compiler when it encounters an asynchronous method. The discussion starts with a high-level conceptual overview and gradually moves towards the intriguing technical details and performance optimizations. https://vkontech.com/exploring-the-async-await-state-machine-series-overview/ 5 comments csharp
- OOP or FP? C# or F#? Is it just a matter of style? This series will give you a lot of food for thought. Enjoy Part #1: https://vkontech.com/clash-of-styles-part-1-operations-matrix-via-oop/ 94 comments csharp
- I wrote a series of articles comparing OOP and FP from a very practical standpoint. Modern general-purpose languages support both of the paradigms. Being conscious of that and choosing the right style for your use case is vital for ending up with an elegant and maintainable system. https://vkontech.com/the-clash-of-styles-series-fp-vs-oop-as-a-daily-choice/ 4 comments fsharp
- FP or OOP is not a binary choice. You can have a healthy mix of the two in your program. Whatever paradigm you select to be central to your design, there will be cases when the other style fits better. Let’s start exploring this in Part #4 of the Clash of Styles https://vkontech.com/clash-of-styles-part-4-adding-support-for-rational-numbers-with-fp/ 6 comments fsharp
- The async/await State Machine can be easily understood with a comprehensive workflow diagram that models the program flow and the state transitions. Such a higher-level representation is a mandatory step before diving into the implementation https://vkontech.com/exploring-the-async-await-state-machine-main-workflow-and-state-transitions/ 9 comments csharp
- Prefer constructor overloads or factory methods over implicit/explicit conversion operators. https://vkontech.com/avoid-conversion-operators/ 19 comments csharp
- The Awaitable Pattern plays a vital role in the whole async/await workflow behind the scenes. The best way to understand how it works is to build your own awaitable type. Let’s see how! https://vkontech.com/exploring-the-async-await-state-machine-the-awaitable-pattern/ 16 comments csharp
- GetHashCode() Pitfalls. The discussion is about C# but most of the content is also applicable to Java. https://vkontech.com/gethashcode-pitfalls/ 3 comments csharp
- The common understanding of Polymorphism takes into account only the runtime type of the “receiving” object. That’s the implementation in most languages. But what if we also consider the method arguments as part of the runtime method resolution logic? That’s the idea behind “Multiple Dispatch.” https://vkontech.com/polymorphism-on-steroids-dive-into-multiple-dispatch-multimethods/ 31 comments programming
- I wrote a series of articles comparing OOP and FP from a very practical standpoint. Modern general-purpose languages support both of the paradigms. Being conscious of that and choosing the right style for your use case is vital for ending up with an elegant and maintainable system. https://vkontech.com/the-clash-of-styles-series-fp-vs-oop-as-a-daily-choice/ 5 comments csharp
- FP or OOP is not a binary choice. You can have a healthy mix of the two in your program. Whatever paradigm you select to be central to your design, there will be cases when the other style fits better. Let’s start exploring this in Part #4 of the Clash of Styles series. https://vkontech.com/clash-of-styles-part-4-adding-support-for-rational-numbers-with-fp/ 74 comments programming
- FP or OOP is not a binary choice. You can have a healthy mix of the two in your program. Whatever paradigm you select to be central to your design, there will be cases when the other style fits better. Let’s start exploring this in Part #4 of the Clash of Styles series. https://vkontech.com/clash-of-styles-part-4-adding-support-for-rational-numbers-with-fp/ 183 comments programming
- The Visitor Pattern addresses a fundamental limitation of Object-Oriented modeling. In OOP, adding a new “operation” is tricky. You have to modify the existing classes, which is error-prone and violates OCP. Let’s look beyond the standard UML diagram and see how the Visitor solves this problem. https://vkontech.com/clash-of-styles-part-6-fp-in-oop-via-the-visitor-pattern/ 20 comments csharp
- FP or OOP is not a binary choice. You can have a healthy mix of the two in your program. Whatever paradigm you select to be central to your design, there will be cases when the other style fits better. Let’s start exploring this in Part #4 of the Clash of Styles series. https://vkontech.com/clash-of-styles-part-4-adding-support-for-rational-numbers-with-fp/ 14 comments dotnet
- OOP is established to the point that we sometimes follow absurdly complicated “idiomatic” patterns(tricks). One example is the Double Dispatch technique, which is a quite puzzling chain of polymorphic calls. Let’s see it in action and compare it to a quite elegant Functional alternative. https://vkontech.com/clash-of-styles-part-5-double-dispatch-or-when-to-abandon-oop/ 74 comments csharp
- FP or OOP is not a binary choice. You can have a healthy mix of the two in your program. Whatever paradigm you select to be central to your design, there will be cases when the other style fits better. Let’s start exploring this in Part #4 of the Clash of Styles series. https://vkontech.com/clash-of-styles-part-4-adding-support-for-rational-numbers-with-fp/ 9 comments csharp
- The FP vs. OOP choice can directly affect the extensibility of your program. What is “easy” to add in OOP is “hard” in FP and vice versa. How can that be presented in terms of the Open-Closed Principle? Explore those topics with practical examples in Part #3 of the Clash of Styles series. https://vkontech.com/clash-of-styles-part-3-extensibility-via-oop-and-fp/ 54 comments csharp
- OOP or FP? C# or F#? Is it just a matter of style? These series will give you a lot of food for thought. Enjoy Part #1: https://vkontech.com/clash-of-styles-part-1-operations-matrix-via-oop/ 23 comments csharp
- An example-driven overview of the Dispose Pattern https://vkontech.com/the-dispose-pattern-step-by-step/ 3 comments dotnet
- A Practical Intro to Covariance and Contravariance in C# https://vkontech.com/a-practical-intro-to-covariance-and-contravariance-in-c/ 3 comments dotnet