Update 10-concurrency.mdx

docs/04-explore-cardano/10-concurrency.mdx

@@ -3,41 +3,20 @@ title: Understanding concurrency
 metaTitle: Understanding concurrency
 ---
 
-Concurrency may or may not improve a system’s performance, throughput, or
-responsiveness. The amount of concurrency limits the maximum number of
-simultaneous operations that can be performed.
-
-To obtain _actual_ performance improvements in a UTXO-based blockchain,
-processors or other actors should be able to perform multiple actions
-simultaneously. The higher the level of concurrency, the higher the maximum
-possible parallelism. Such an approach then translates to performance
-improvements and throughput. It also provides significant advantages over
-account based systems (like Ethereum).
-
-## Deploying DApps on UTXO ledgers is different
-
-Cardano’s approach to DApp deployment is different and thus it requires a
-learning curve and a different approach. This is like working with different
-programming languages: there is one goal – to deploy a solution, but so many
-programming languages to use for this purpose.
-
-Maximizing concurrency is a skill that needs to be learned: developers need to
-write code in a way that severely restricts the opportunities for contention
-(e.g., by avoiding shared states and accidental dependencies). The system must
-then translate this concurrency into parallelism. A number of developers have
-already identified ways to approach this, while others are still developing
-solutions. Simply transplanting lessons learned on one blockchain will not work;
-while the learning curve is a little steeper, the results make this worthwhile.
-
-Either way, it is important to understand that to deploy a scalable DApp on
-Cardano, a developer can’t just use an adapted Ethereum contract. Cardano is
-based on the UTXO model; it is not account-based which means that a single
-on-chain state will not meet the concurrency property of Cardano. Instead, DApps
-should split up their on-chain state across many UTXOs. This will increase the
-concurrency in their application, thereby allowing higher throughput.
-
-To learn more about scalability, you can read
-[how to design a scalable Plutus application](https://plutus-apps.readthedocs.io/en/stable/plutus/howtos/writing-a-scalable-app.html)
-and to learn more about how to organise DApps on Cardano using patterns, read
-the
-[order book pattern](https://plutus-apps.readthedocs.io/en/stable/plutus/explanations/order-book-pattern.html).
+Concurrency refers to the ability of different actors to perform work simultaneously without interfering with each other. In Cardano's Extended Unspent Transaction Output (EUTXO) model, transactions can be processed in parallel, enabling multiple operations without causing system failures. This approach enhances system throughput while maintaining the performance of individual operations.
+
+The EUTXO model, employed by Cardano, allows for secure and predictable execution of smart contracts. By splitting logic across different branches and utilizing multiple UTXOs, Cardano achieves greater parallelism, leading to improved scalability.
+
+The level of concurrency sets the limit for simultaneous operations. Developers should adopt strategies to minimize contention and translate concurrency into parallelism, which may involve a learning curve but yields significant benefits.
+
+:::info
+
+Learn more:
+
+- [Concurrency: Cardano smart contracts and the EUTXO model](https://www.essentialcardano.io/article/concurrency-and-all-that-cardano-smart-contracts-and-the-eutxo-model)
+- [How to design a scalable Plutus application](https://plutus-apps.readthedocs.io/en/stable/plutus/howtos/writing-a-scalable-app.html)
+- [About the order book pattern](https://plutus-apps.readthedocs.io/en/stable/plutus/explanations/order-book-pattern.html).
+
+:::
+
+