by Joche Ojeda | Jun 10, 2024 | Blockchain, C#, Smart contracts, Stratis
Introduction
Blockchain technology has revolutionized various industries by providing a decentralized and secure way to manage data and transactions. At the heart of this innovation are smart contracts—self-executing contracts with the terms directly written into code. My journey into blockchain development began with the excitement of these possibilities, but it also came with challenges, particularly with the Solidity programming language. However, everything changed when I discovered the Stratis platform, which supports smart contracts using C#, making development much more accessible for me. In this article, I’ll share my experiences, challenges, and the eventual breakthrough that came with Stratis.
Challenges with Solidity
Solidity is the most popular language for writing smart contracts on Ethereum, but it has a steep learning curve. My background in programming didn’t include a lot of JavaScript-like languages, so adapting to Solidity’s syntax and concepts was daunting. The process of writing, testing, and deploying smart contracts often felt cumbersome. Debugging was a particular pain point, with cryptic error messages and a lack of mature tooling compared to more established programming environments.
The complexity and frustration of dealing with these issues made me seek an alternative that could leverage my existing programming skills. I wanted a platform that was easier to work with and more aligned with languages I was already comfortable with. This search led me to discover Stratis.
Introduction to Stratis
Stratis is a blockchain development platform designed to meet the needs of enterprises and developers by offering a simpler and more efficient way to build blockchain solutions. What caught my attention was its support for C#—a language I was already proficient in. Stratis allows developers to create smart contracts using C#, integrating seamlessly with the .NET ecosystem.
This discovery was a game-changer for me. The prospect of using a familiar language in a robust development environment like Visual Studio, combined with the powerful features of Stratis, promised a much smoother and more productive development experience.
Why Stratis Stood Out
The primary benefit of using C# over Solidity is the familiarity and maturity of the development tools. With C#, I could leverage the rich ecosystem of libraries, tools, and frameworks available in the .NET environment. This not only sped up the development process but also reduced the time spent on debugging and testing.
Stratis offers a comprehensive suite of tools designed to simplify blockchain development. The Stratis Full Node, for instance, provides a fully functional blockchain node that can be easily integrated into existing applications. Additionally, Stratis offers a smart contract template for Visual Studio, making it straightforward to start building and deploying smart contracts.
Another significant advantage is the support and community around Stratis. The documentation is thorough, and the community is active, providing a wealth of resources and assistance for developers at all levels.
Conclusion
Transitioning from Solidity to Stratis was a pivotal moment in my blockchain development journey. The challenges I faced with Solidity were mitigated by the ease and familiarity of C#. Stratis provided a robust and efficient platform that significantly improved my development workflow.
In the next article, I will dive into the practical steps of setting up the Stratis development environment. We’ll cover everything you need to get started, from installing the necessary tools to configuring your first Stratis Full Node. Stay tuned for a detailed guide that will set the foundation for your journey into C# smart contract development.
by Joche Ojeda | Jun 10, 2024 | C#, Data Synchronization, dotnet
The Ephemeral State of SOLID Code: Capturing the Perfect Snapshot
In the world of software development, the SOLID principles are often upheld as the gold standard for designing maintainable and scalable code. These principles — Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion — form the bedrock of robust object-oriented design. However, achieving a state where code fully adheres to these principles is a fleeting moment, much like capturing a perfect snapshot in time.
What Does It Mean for Code to Be in a SOLID State?
A SOLID state in source code is a condition where the code perfectly aligns with all five SOLID principles. This means:
- Single Responsibility Principle (SRP): Every class has one, and only one, reason to change.
- Open/Closed Principle (OCP): Software entities should be open for extension but closed for modification.
- Liskov Substitution Principle (LSP): Subtypes must be substitutable for their base types.
- Interface Segregation Principle (ISP): No client should be forced to depend on methods it does not use.
- Dependency Inversion Principle (DIP): Depend on abstractions, not concretions.
In this state, the codebase is a model of clarity, flexibility, and robustness. But this state is inherently transient.
The Moment of SOLID Perfection
The reality of software development is that code is in a constant state of flux. New features are added, bugs are fixed, and refactoring is a continuous process. During these periods of active development, maintaining perfect adherence to SOLID principles is challenging. The code may temporarily violate one or more principles as developers refactor or introduce new functionality.
The truly SOLID state can thus be seen as a snapshot — a moment frozen in time when the code perfectly adheres to all five principles. This moment typically occurs:
- Post-Refactoring: After a significant refactoring effort, where the focus has been on aligning the code with SOLID principles.
- Before Major Changes: Just before starting a new major feature or overhaul, the existing codebase might be in a perfect SOLID state.
- Code Reviews: Following a rigorous code review process, where adherence to SOLID principles is explicitly checked and enforced.
- Milestone Deliveries: Before delivering a major milestone or release, when the code is thoroughly tested and cleaned up.
The Nature of Active Development
Active development is a chaotic process. As new requirements emerge and priorities shift, developers might temporarily sacrifice adherence to SOLID principles for the sake of rapid progress or to meet deadlines. This is a natural part of the development cycle. The key is to recognize that while the code may deviate from these principles during active development, the goal is to continually steer it back towards a SOLID state.
The SOLID State as Nirvana
Achieving a perfect SOLID state can be likened to reaching nirvana — an ideal that is almost impossible to fully attain. Just as nirvana represents a state of ultimate peace and enlightenment, a perfectly SOLID codebase represents the pinnacle of software design. However, this state is incredibly difficult to reach and even harder to maintain. Therefore, it is more practical to view adherence to SOLID principles as a spectrum rather than a binary state.
Measuring SOLID Adherence
Instead of aiming for an elusive perfect state, it’s more pragmatic to measure adherence to SOLID principles using metrics. Tools and techniques can help quantify how well your code aligns with each principle, providing a percentage that reflects its current state. These metrics can include:
- Class Responsibility: Assessing the number of responsibilities each class has to evaluate adherence to SRP.
- Change Impact Analysis: Measuring the extent to which modifications to the code require changes in other parts of the system, reflecting adherence to OCP.
- Subtype Tests: Ensuring subclasses can replace their base classes without altering the correctness of the program, in line with LSP.
- Interface Utilization: Analyzing the usage of interfaces to ensure they are not overly broad, adhering to ISP.
- Dependency Metrics: Evaluating dependencies between high-level and low-level modules, supporting DIP.
By regularly measuring these metrics, developers can maintain a clear view of how their code is evolving in relation to SOLID principles. This approach allows for continuous improvement and helps teams prioritize refactoring efforts where they are most needed.
Embracing the Snapshot
Understanding that a perfectly SOLID state is a temporary snapshot can help developers maintain a healthy perspective. It’s crucial to strive for SOLID principles as a guiding star but also to accept that deviations are part of the journey. Regular refactoring sessions, continuous integration practices, and diligent code reviews are essential practices to frequently bring the code back to a SOLID state.
Conclusion
In conclusion, a SOLID state of source code is a valuable but ephemeral achievement, akin to reaching nirvana in the realm of software development. It represents a moment of perfection in the ongoing evolution of a software project. By recognizing this, developers can better manage their expectations and maintain a balance between striving for perfection and the practical realities of software development. Embrace the snapshot of SOLID perfection when it occurs, but also understand that the true measure of a healthy codebase is its ability to evolve while frequently realigning with these timeless principles, using metrics and percentages to guide the way.
by Joche Ojeda | Jun 5, 2024 | C#, Data Synchronization
Introduction
In modern API development, choosing the correct return type is crucial for performance, flexibility, and maintainability. In my SyncFramework server API, I opted to use strings as the return type. This decision stems from the need to serialize messages efficiently and flexibly, ensuring seamless communication between the server and client. This article explores the rationale behind this choice, specifically focusing on C# code with HttpClient and Web API on the server side.
The Problem
When building APIs, data serialization and deserialization are fundamental operations. Typically, APIs return objects that are automatically serialized into JSON or XML. While this approach is straightforward, it can introduce several challenges:
- Performance Overhead: Automatic serialization/deserialization can add unnecessary overhead, especially for large or complex data structures.
- Lack of Flexibility: Relying on default serialization mechanisms can limit control over the serialization process, making it difficult to customize data formats or handle specific serialization requirements.
- Interoperability Issues: Different clients may require different data formats. Sticking to a single format can lead to compatibility issues.
The Solution: Using Strings
To address these challenges, I decided to use strings as the return type for my API. Here’s why:
- Control Over Serialization: By returning a string, I can serialize the data myself, ensuring that the format meets specific requirements. This control is essential for optimizing the data format and ensuring compatibility with various clients.
- Performance Optimization: Custom serialization allows me to optimize the data structure, potentially reducing the size of the serialized data and improving transmission efficiency. For example, converting a complex object to a compressed byte array and then encoding it as a string can save bandwidth.
- Flexibility: Using strings enables me to easily switch between different serialization formats (e.g., JSON, XML, binary) based on the client’s needs without changing the API contract. This flexibility is crucial for maintaining backward compatibility and supporting multiple client types.
Implementation in C#
Here’s a practical example of how this approach is implemented using C#:
Server Side: Web API
using System;
using System.Text;
using System.Web.Http;
public class MyApiController : ApiController
{
[HttpGet]
[Route("api/getdata")]
public IHttpActionResult GetData()
{
var data = new MyData
{
Id = 1,
Name = "Sample Data"
};
// Custom serialization to JSON string
var serializedData = SerializeData(data);
return Ok(serializedData);
}
private string SerializeData(MyData data)
{
// Use custom serialization logic (e.g., JSON, XML, or binary)
return Newtonsoft.Json.JsonConvert.SerializeObject(data);
}
}
public class MyData
{
public int Id { get; set; }
public string Name { get; set; }
}
Client Side: HttpClient
using System;
using System.Net.Http;
using System.Threading.Tasks;
public class ApiClient
{
private readonly HttpClient _httpClient;
public ApiClient()
{
_httpClient = new HttpClient();
}
public async Task GetDataAsync()
{
var response = await _httpClient.GetStringAsync("http://localhost/api/getdata");
// Custom deserialization from JSON string
return DeserializeData(response);
}
private MyData DeserializeData(string serializedData)
{
// Use custom deserialization logic (e.g., JSON, XML, or binary)
return Newtonsoft.Json.JsonConvert.DeserializeObject(serializedData);
}
}
public class MyData
{
public int Id { get; set; }
public string Name { get; set; }
}
Benefits Realized
By using strings as the return type, the SynFramework server API achieves several benefits:
- Enhanced Performance: Custom serialization reduces the payload size and improves response times.
- Greater Flexibility: The ability to easily switch serialization formats ensures compatibility with various clients.
- Better Control: Custom serialization allows fine-tuning of the data format, improving both performance and interoperability.
Conclusion
Choosing strings as the return type for the SyncFramework server API offers significant advantages in terms of performance, flexibility, and control over the serialization process. This approach simplifies the management of data formats, ensures efficient data transmission, and enhances compatibility with diverse clients. For developers working with C# and Web API, this strategy provides a robust solution for handling API responses effectively.
by Joche Ojeda | Jun 3, 2024 | C#, Data Synchronization
Writing Reusable Tests for SyncFramework Interfaces in C#
When creating a robust database synchronization framework like SyncFramework, ensuring that each component adheres to its defined interface is crucial. Reusable tests for interfaces are an essential aspect of this verification process. Here’s how you can approach writing reusable tests for your interfaces in C#:
1. Understand the Importance of Interface Testing
Interfaces define contracts that all implementing classes must follow. By testing these interfaces, you ensure that every implementation behaves as expected. This is especially important in frameworks like SyncFramework, where different components (e.g., IDeltaStore) need to be interchangeable.
2. Create Base Test Classes
Create abstract test classes for each interface. These test classes should contain all the tests that verify the behavior defined by the interface.
using Microsoft.VisualStudio.TestTools.UnitTesting;
public abstract class BaseDeltaStoreTest
{
protected abstract IDeltaStore GetDeltaStore();
[TestMethod]
public void TestAddDelta()
{
var deltaStore = GetDeltaStore();
deltaStore.AddDelta("delta1");
Assert.IsTrue(deltaStore.ContainsDelta("delta1"));
}
[TestMethod]
public void TestRemoveDelta()
{
var deltaStore = GetDeltaStore();
deltaStore.AddDelta("delta2");
deltaStore.RemoveDelta("delta2");
Assert.IsFalse(deltaStore.ContainsDelta("delta2"));
}
// Add more tests to cover all methods in IDeltaStore
}
3. Implement Concrete Test Classes
For each implementation of the interface, create a concrete test class that inherits from the base test class and provides an implementation for the abstract method to instantiate the concrete class.
using Microsoft.VisualStudio.TestTools.UnitTesting;
[TestClass]
public class ConcreteDeltaStoreTest : BaseDeltaStoreTest
{
protected override IDeltaStore GetDeltaStore()
{
return new ConcreteDeltaStore();
}
}
4. Use a Testing Framework
Utilize a robust testing framework such as MSTest, NUnit, or xUnit to ensure all tests are run across all implementations.
5. Automate Testing
Integrate your tests into your CI/CD pipeline to ensure that every change is automatically tested across all implementations. This ensures that any new implementation or modification adheres to the interface contracts.
6. Document Your Tests
Clearly document your tests and the rationale behind reusable tests for interfaces. This will help other developers understand the importance of these tests and encourage them to add tests for new implementations.
Example of Full Implementation
// IDeltaStore Interface
public interface IDeltaStore
{
void AddDelta(string delta);
void RemoveDelta(string delta);
bool ContainsDelta(string delta);
}
// Base Test Class
using Microsoft.VisualStudio.TestTools.UnitTesting;
public abstract class BaseDeltaStoreTest
{
protected abstract IDeltaStore GetDeltaStore();
[TestMethod]
public void TestAddDelta()
{
var deltaStore = GetDeltaStore();
deltaStore.AddDelta("delta1");
Assert.IsTrue(deltaStore.ContainsDelta("delta1"));
}
[TestMethod]
public void TestRemoveDelta()
{
var deltaStore = GetDeltaStore();
deltaStore.AddDelta("delta2");
deltaStore.RemoveDelta("delta2");
Assert.IsFalse(deltaStore.ContainsDelta("delta2"));
}
// Add more tests to cover all methods in IDeltaStore
}
// Concrete Implementation
public class ConcreteDeltaStore : IDeltaStore
{
private readonly HashSet _deltas = new HashSet();
public void AddDelta(string delta)
{
_deltas.Add(delta);
}
public void RemoveDelta(string delta)
{
_deltas.Remove(delta);
}
public bool ContainsDelta(string delta)
{
return _deltas.Contains(delta);
}
}
// Concrete Implementation Test Class
using Microsoft.VisualStudio.TestTools.UnitTesting;
[TestClass]
public class ConcreteDeltaStoreTest : BaseDeltaStoreTest
{
protected override IDeltaStore GetDeltaStore()
{
return new ConcreteDeltaStore();
}
}
// Running the tests
// Ensure to use a test runner compatible with MSTest to execute the tests
by Joche Ojeda | May 15, 2024 | C#, dotnet, Linux, Ubuntu, WSL
Hello, dear readers! Today, we’re going to talk about something called the Windows Subsystem for Linux, or WSL for short. Now, don’t worry if you’re not a tech wizard – this guide is meant to be approachable for everyone!
What is WSL?
In simple terms, WSL is a feature in Windows that allows you to use Linux right within your Windows system. Think of it as having a little bit of Linux magic right in your Windows computer!
Why Should I Care?
Well, WSL is like having a Swiss Army knife on your computer. It can make certain tasks easier and faster, and it can even let you use tools that were previously only available on Linux.
Is It Hard to Use?
Not at all! If you’ve ever used the Command Prompt on your Windows computer, then you’re already halfway there. And even if you haven’t, there are plenty of easy-to-follow guides out there to help you get started.
Do I Need to Be a Computer Expert to Use It?
Absolutely not! While WSL is a powerful tool that many developers love to use, it’s also quite user-friendly. With a bit of curiosity and a dash of patience, anyone can start exploring the world of WSL.
As a DotNet developer, you might be wondering why there’s so much buzz around the Windows Subsystem for Linux (WSL). Let’s dive into the reasons why WSL could be a game-changer for you.
- Seamless Integration: WSL provides a full-fledged Linux environment right within your Windows system. This means you can run Linux commands and applications without needing a separate machine or dual-boot setup.
- Development Environment Consistency: With WSL, you can maintain consistency between your development and production environments, especially if your applications are deployed on Linux servers. This can significantly reduce the “it works on my machine” syndrome.
- Access to Linux-Only Tools: Some tools and utilities are only available or work better on Linux. WSL brings these tools to your Windows desktop, expanding your toolkit without additional overhead.
- Improved Performance: WSL 2, the latest version, runs a real Linux kernel inside a lightweight virtual machine (VM), which leads to faster file system performance and complete system call compatibility.
- Docker Support: WSL 2 provides full Docker support without requiring additional layers for translation between Windows and Linux, resulting in a more efficient and seamless Docker experience.
In conclusion, WSL is not just a fancy tool; it’s a powerful ally that can enhance your productivity and capabilities as a DotNet developer.
by Joche Ojeda | May 14, 2024 | C#, Data Synchronization, dotnet
Hello there! Today, we’re going to delve into the fascinating world of design patterns. Don’t worry if you’re not a tech whiz – we’ll keep things simple and relatable. We’ll use the SyncFramework as an example, but our main focus will be on the design patterns themselves. So, let’s get started!
What are Design Patterns?
Design patterns are like blueprints – they provide solutions to common problems that occur in software design. They’re not ready-made code that you can directly insert into your program. Instead, they’re guidelines you can follow to solve a particular problem in a specific context.
SOLID Design Principles
One of the most popular sets of design principles is SOLID. It’s an acronym that stands for five principles that help make software designs more understandable, flexible, and maintainable. Let’s break it down:
- Single Responsibility Principle: A class should have only one reason to change. In other words, it should have only one job.
- Open-Closed Principle: Software entities should be open for extension but closed for modification. This means we should be able to add new features or functionality without changing the existing code.
- Liskov Substitution Principle: Subtypes must be substitutable for their base types. This principle is about creating new derived classes that can replace the functionality of the base class without breaking the application.
- Interface Segregation Principle: Clients should not be forced to depend on interfaces they do not use. This principle is about reducing the side effects and frequency of required changes by splitting the software into multiple, independent parts.
- Dependency Inversion Principle: High-level modules should not depend on low-level modules. Both should depend on abstractions. This principle allows for decoupling.
Applying SOLID Principles in SyncFramework
The SyncFramework is a great example of how these principles can be applied. Here’s how:
- Single Responsibility Principle: Each component of the SyncFramework has a specific role. For instance, one component is responsible for tracking changes, while another handles conflict resolution.
- Open-Closed Principle: The SyncFramework is designed to be extensible. You can add new data sources or change the way data is synchronized without modifying the core framework.
- Liskov Substitution Principle: The SyncFramework uses base classes and interfaces that allow for substitutable components. This means you can replace or modify components without affecting the overall functionality.
- Interface Segregation Principle: The SyncFramework provides a range of interfaces, allowing you to choose the ones you need and ignore the ones you don’t.
- Dependency Inversion Principle: The SyncFramework depends on abstractions, not on concrete classes. This makes it more flexible and adaptable to changes.
And that’s a wrap for today! But don’t worry, this is just the beginning. In the upcoming series of articles, we’ll dive deeper into each of these principles. We’ll explore how they’re applied in the source code of the SyncFramework, providing real-world examples to help you understand these concepts better. So, stay tuned for more exciting insights into the world of design patterns! See you in the next article!
Related articles
If you want to learn more about data synchronization you can checkout the following blog posts:
- Data synchronization in a few words – https://www.jocheojeda.com/2021/10/10/data-synchronization-in-a-few-words/
- Parts of a Synchronization Framework – https://www.jocheojeda.com/2021/10/10/parts-of-a-synchronization-framework/
- Let’s write a Synchronization Framework in C# – https://www.jocheojeda.com/2021/10/11/lets-write-a-synchronization-framework-in-c/
- Synchronization Framework Base Classes – https://www.jocheojeda.com/2021/10/12/synchronization-framework-base-classes/
- Planning the first implementation – https://www.jocheojeda.com/2021/10/12/planning-the-first-implementation/
- Testing the first implementation – https://youtu.be/l2-yPlExSrg
- Adding network support – https://www.jocheojeda.com/2021/10/17/syncframework-adding-network-support/
