Franco

Software Engineer - Passionate Developer
#fmoralesDev #dotnet
#Utniano
#KeepLearning
#KeepFocusing
#KeepPositive
#KeepItSimple
#HaveGoals

[Anton Martyniuk @AntonMartyniuk]

𝗧𝗼𝗽 𝟭𝟬 𝗺𝗼𝘀𝘁 𝗵𝗮𝗿𝗺𝗳𝘂𝗹 𝗡𝘂𝗚𝗲𝘁 𝗽𝗮𝗰𝗸𝗮𝗴𝗲𝘀 𝘆𝗼𝘂'𝗿𝗲 𝘂𝘀𝗶𝗻𝗴 𝘄𝗶𝘁𝗵𝗼𝘂𝘁 𝗿𝗲𝗮𝗹𝗶𝘇𝗶𝗻𝗴 𝗶𝘁!

You might think these popular .NET packages make your life easier — but they often introduce hidden issues 👇

1️⃣ 𝗔𝘂𝘁𝗼𝗠𝗮𝗽𝗽𝗲𝗿
Encourages overly-complex mapping logic hidden behind profiles. AutoMapper is slow and makes debugging almost impossible.
👉 Better choice: Manual mapping

2️⃣ 𝗠𝗲𝗱𝗶𝗮𝘁𝗥
Adds unnecessary reflection overhead and complexity.
👉 Better choice: Own manual handlers

3️⃣ 𝗡𝗲𝘄𝘁𝗼𝗻𝘀𝗼𝗳𝘁.𝗝𝘀𝗼𝗻
Heavy and slower compared to newer, built-in options.
👉 Better choice: System.Text.Json

4️⃣ 𝗙𝗹𝘂𝗲𝗻𝘁𝗔𝘀𝘀𝗲𝗿𝘁𝗶𝗼𝗻𝘀
Now has a paid license for commercial use.
👉 Better choice: Shouldly or xUnit assertions

5️⃣ 𝗥𝗲𝘀𝘁𝗦𝗵𝗮𝗿𝗽
Has become outdated and less intuitive compared to modern HTTP clients.
👉 Better choice: Refit

6️⃣ 𝗔𝘂𝘁𝗼𝗙𝗮𝗰
Outdated DI container adding unnecessary complexity.
👉 Better choice: Microsoft DI

7️⃣ NServiceBus
Expensive licensing model in production and complex setup.
👉 Better choice: MassTransit, Wolverine

8️⃣ 𝗔𝘂𝘁𝗼𝗙𝗶𝘅𝘁𝘂𝗿𝗲
Produces unrealistic, hard to understand tests with randomly-generated data.
👉 Better choice: Bogus

9️⃣ 𝗡𝗦𝘂𝗯𝘀𝘁𝗶𝘁𝘂𝘁𝗲
Its syntax uses the original interface, leading to confusing, unclear tests.
👉 Better choice: Moq

🔟 𝗡𝗨𝗻𝗶𝘁
Older, verbose framework with outdated practices.
👉 Better choice: xUnit

Which harmful packages are you still using in your projects? Drop in the comment below! 👇

♻️ Repost to help your network learn about harmful NuGet packages

➕ Follow me (@AntonMartyniuk) for more

#Dotnet

[Anton Martyniuk @AntonMartyniuk]

𝟵𝟬% 𝗼𝗳 𝗔𝗣𝗜𝘀 𝗮𝗿𝗲 𝗻𝗼𝘁 𝗥𝗘𝗦𝗧𝗳𝘂𝗹

Web APIs can't be fully RESTful without a GPS 👇

According to Richardson's REST Maturity Model, there are four levels of REST APIs:

• Level 0 (Swamp of POX): Plain XML or JSON with a single endpoint.

• Level 1 (Resources): Separate resources with unique URIs.

• Level 2 (HTTP Verbs): Proper HTTP methods (GET, POST, PUT, DELETE, PATCH).

• Level 3 (HATEOAS): APIs provide links dynamically, guiding clients through possible actions and states.

Most APIs are stuck at level 2, missing the 𝗛𝗔𝗧𝗘𝗢𝗔𝗦.

HATEOAS: Hypermedia as the Engine of Application State.

Why should you care?

Without HATEOAS, your clients are tightly coupled to endpoints, causing costly changes and maintenance.

𝗛𝗔𝗧𝗘𝗢𝗔𝗦 𝗶𝘀 𝗚𝗣𝗦 𝗳𝗼𝗿 𝗔𝗣𝗜𝘀:

↳ Dynamically guides API clients through the available actions and states using embedded links

↳ Provides directions to navigate routes, HATEOAS gives clients clear paths to interact with your API without hard-coding specific endpoints

↳ This flexibility ensures your API remains robust and easy to integrate, even as it evolves.

❌ Without HATEOAS, the frontend copies business checks from the backend to determine whether to put an "update" button or not. Often, backend and frontend can go out of sync, leading to bugs.

✅ With HATEOAS, server sends the "Update Link" to the frontend. No need to re-implement complex business checks to determine whether a user is allowed to update the resource.

This approach shifts complexity to one place — the backend, where it belongs.

Are you integrating HATEOAS into your APIs, or are they still stuck at Level 2?
Let me know in the comments below 👇

♻️ Follow me @AntonMartyniuk and repost this to help others

▶️ Subscribe to my free newsletter to learn how to craft better Web APIs:
↳ https://t.co/bSLiKbOlRR

#dotnet

[Stefan Đokić | .NET @TheCodeMan__]

What is the Chain Responsibility Pattern?

When should I implement it?
How to implement it?

The Chain of Responsibility Pattern allows us to easily separate dependent parts to make code more extensible and testable.

In simple words, we can say that the chain of responsibility design pattern creates a chain of receiver objects for a given request.

In this design pattern, normally each receiver contains a reference to another receiver. If one receiver cannot handle the request then it passes the same request to the next receiver and so on. One receiver handles the request in the chain or one or more receivers handle the request.

I explained and implemented it in my newsletter issue. If you are interested in learning how it works, check it out here: https://t.co/0pLNKnt38K

Be sure not to miss the next one.
Join 8500+ engineers here: https://t.co/jHf5a4qQTZ

[Milan Jovanović @mjovanovictech]

Integration tests using Docker?

The Testcontainers library can spin up a Docker container inside your test.

I use it to create a PostgreSQL instance, so my test can now run using a real database.

Go from 0 to Hero by watching my Testconatiners video 👇

https://t.co/GFgDJfQisF

[Dave Callan | dotnet @Dave_DotNet]

How to find slow queries in Entity Framework ⬇

By using Entity Frameworks interceptor system and hooking into the ReaderExecuted event we can see exactly how long queries are taking to execute.

Bookmark it!

#dotnet #efcore

[Franco @MoralesFranco1]

@sebarosenbolt Jajaja sin invite nos vimos, una reunión menos mejor jaja

[Milan Jovanović @mjovanovictech]

I implemented API Key authentication for a .NET 7 project.

Here's what I learned.

API key authentication is a method of identifying and granting access to specific users or systems that need to consume an API.

The client passes an API Key that is used to authenticate it.

[Alex Xu @alexxubyte]

Docker vs. Kubernetes. Which one should we use?

What is Docker ?
Docker is an open-source platform that allows you to package, distribute, and run applications in isolated containers. It focuses on containerization, providing lightweight environments that encapsulate applications and their dependencies.

What is Kubernetes ?
Kubernetes, often referred to as K8s, is an open-source container orchestration platform. It provides a framework for automating the deployment, scaling, and management of containerized applications across a cluster of nodes.

How are both different from each other ?
Docker: Docker operates at the individual container level on a single operating system host.

You must manually manage each host and setting up networks, security policies, and storage for multiple related containers can be complex.

Kubernetes: Kubernetes operates at the cluster level. It manages multiple containerized applications across multiple hosts, providing automation for tasks like load balancing, scaling, and ensuring the desired state of applications.

In short, Docker focuses on containerization and running containers on individual hosts, while Kubernetes specializes in managing and orchestrating containers at scale across a cluster of hosts.

Over to you: What challenges prompted you to switch from Docker to Kubernetes for managing containerized applications?

–
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://t.co/4QcX8btXGL

[Mía Salazar 🍪🎲 @miadeveloper]

Hace poco me hice un curso buenísimo sobre accesibilidad que es gratuito.

Lo recomiendo 100%

Link: https://t.co/aH3N4JV2Vb

[Milan Jovanović @mjovanovictech]

C# Tip 💡

Did you know you can use 𝗲𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻-𝗯𝗼𝗱𝘆 𝗰𝗼𝗻𝘀𝘁𝗿𝘂𝗰𝘁𝗼𝗿𝘀?

Expression body constructors have been available since C# 7.

You specify the arguments using a tuple and deconstruct them into the property values.

[Aurimas Griciūnas @Aurimas_Gr]

What are the most common 𝗨𝘀𝗲 𝗖𝗮𝘀𝗲𝘀 𝗳𝗼𝗿 𝗞𝗮𝗳𝗸𝗮?

We have covered lots of concepts around Kafka already. But what are the most common use cases for The System that you are very likely to run into as a Data Engineer?

𝗟𝗲𝘁’𝘀 𝘁𝗮𝗸𝗲 𝗮 𝗰𝗹𝗼𝘀𝗲𝗿 𝗹𝗼𝗼𝗸:

𝗪𝗲𝗯𝘀𝗶𝘁𝗲 𝗔𝗰𝘁𝗶𝘃𝗶𝘁𝘆 𝗧𝗿𝗮𝗰𝗸𝗶𝗻𝗴.

➡️ The Original use case for Kafka by LinkedIn.
➡️ Events happening in the website like page views, conversions etc. are sent via a Gateway and piped to Kafka Topics.
➡️ These events are forwarded to the downstream Analytical systems or processed in Real Time.
➡️ Kafka is used as an initial buffer as the Data amounts are usually big and Kafka guarantees no message loss due to its replication mechanisms.

𝗗𝗮𝘁𝗮𝗯𝗮𝘀𝗲 𝗥𝗲𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻.

➡️ Database Commit log is piped to a Kafka topic.
➡️ The committed messages are executed against a new Database in the same order.
➡️ Database replica is created.

𝗟𝗼𝗴/𝗠𝗲𝘁𝗿𝗶𝗰𝘀 𝗔𝗴𝗴𝗿𝗲𝗴𝗮𝘁𝗶𝗼𝗻.

➡️ Kafka is used for centralized Log and Metrics collection.
➡️ Daemons like FluentD are deployed in servers or containers together with the Applications to be monitored.
➡️ Applications send their Logs/Metrics to the Daemons.
➡️ The Daemons pipe Logs/Metrics to a Kafka Topic.
➡️ Logs/Metrics are delivered downstream to storages like ElasticSearch or InfluxDB for Log/Metrics discovery respectively.
➡️ This is also how you would track your IoT Fleets.

𝗦𝘁𝗿𝗲𝗮𝗺 𝗣𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴.

➡️ This is usually coupled with ingestion mechanisms already covered.
➡️ Instead of piping Data to a certain storage downstream we mount a Stream Processing Framework on top of Kafka Topics.
➡️ The Data is filtered, enriched and then piped to the downstream systems to be further used according to the use case.
➡️ This is also where one would be running Machine Learning Models embedded into a Stream Processing Application.

𝗠𝗲𝘀𝘀𝗮𝗴𝗶𝗻𝗴.

➡️ Kafka can be used as a replacement for more traditional messaging brokers like RabbitMQ.
➡️ Kafka has better durability guarantees and is easier to configure for several separate Consumer Groups to consume from the same Topic.

❗️Having said this - always consider the complexity you are bringing with introduction of a Distributed System. Sometimes it is better to just use traditional frameworks.

--------

Follow me to upskill in #MLOps, #MachineLearning, #DataEngineering, #DataScience and overall #Data space.

Also hit 🔔to stay notified about new content.
𝗗𝗼𝗻’𝘁 𝗳𝗼𝗿𝗴𝗲𝘁 𝘁𝗼 𝗹𝗶𝗸𝗲 💙, 𝘀𝗵𝗮𝗿𝗲 𝗮𝗻𝗱 𝗰𝗼𝗺𝗺𝗲𝗻𝘁!

Join a growing community of Data Professionals by subscribing to my 𝗡𝗲𝘄𝘀𝗹𝗲𝘁𝘁𝗲𝗿: https://t.co/qgNCnGtF4A

[David Fowler @davidfowl]

.NET 8's dependency injection container will support "keyed services". A long-requested feature that has finally landed. This is useful when type alone isn't enough to determine the right implementation. #dotnet

[Alex Xu @alexxubyte]

/1 How does Docker work?

A comparison of Docker-based and non-Docker-based development is shown below.

[Mukesh Murugan @iammukeshm]

🚀 Backend Developer Roadmap for .NET Developers. (2023 Edition)

Follow this thread along for the entire roadmap.

#dotnet #developer #backend

[Franco @MoralesFranco1]

@PersonalFlow_At buenas estoy sin Internet hace 4h me vengo quejando y no me dan bola, me pueden dar una mano?

[Franco @MoralesFranco1]

@PersonalFlow_At buenas estoy sin Internet desde ayer, aunque sea tenía cable clásico hasta hace unos minutos ahora ni Internet, ni cable clásico ni flow. En cuanto me solucionan esto???

[Brais Moure @MoureDev]

Este es el mejor regalo de navidad que podía recibir...

Mi repo de GitHub para aprender Python sigue escalando puestos en tendencias 🥰

🔗 https://t.co/d3ZAemVu07

🏆 Top 8 a nivel mundial
🥇 Top 1 a nivel mundial de Python
🥇 Top 1 (2 y 5) de habla hispana

No os merezco 🙌

[ErikEJ @ErikEJ]

Major new APIs in the latest daily RC1 Entity Framework Core 7 build:
ExecuteDelete - immediate non-tracking bulk delete
ExecuteUpdate - immediate non-tracking bulk update
SqlQuery<T> - ad-hoc raw SQL returning a list of scalar, simple types (classes coming in EF Core 8)
#efcore

[𝙽𝚎𝚛𝚍𝚘 @gordodeinternet]

Desarrolladores de Software: Expectativas vs. realidad

[Carlos Azaustre @carlosazaustre]

🧵 Recursos sobre Clean Architecture/Hexagonal aplicada al Frontend con React.js

Si conoces alguno más, compártelo por aquí.
¡Aprendamos entre todos!
👇