Forem: Ravikant Vijayvargiya

[Boost]

Ravikant Vijayvargiya — Fri, 31 Oct 2025 07:00:41 +0000

Microservices: Service-to-service invocation with Dapr, docker-compose, and .NET

Ravikant Vijayvargiya ・ Aug 30 '24

#csharp #docker #dapr #beginners

Discovering the Hidden Dependencies in Your DLLs

Ravikant Vijayvargiya — Wed, 26 Feb 2025 10:14:21 +0000

This cool application finds all the dependent DLLs of the provided DLL.

GitHub Repo:- https://github.com/lucasg/Dependencies

Download from here

Just unzip the folder, run DependenciesGui, and upload the DLL file to see the results.

Cool website to edit PDF

Ravikant Vijayvargiya — Sat, 25 Jan 2025 09:22:39 +0000

https://www.sejda.com/pdf-editor

Simple to use. You can easily add and remove content.

LLM Visualization

Ravikant Vijayvargiya — Thu, 16 Jan 2025 09:06:30 +0000

LLM Visualization: A 3D animated visualization of an LLM with a walkthrough.

This website demonstrates various LLM models, such as GPT-2(small), nano-GPT, and GPT -3.

https://bbycroft.net/llm

Remove Windows software completely

Ravikant Vijayvargiya — Thu, 05 Dec 2024 06:25:19 +0000

Windows uninstall/remove software feature is good but does not completely remove the software. For example, if you uninstall Chrome browser and install it again, you may find previous data.

Sometimes we want to wipe out a software and its data completely.
I find Revo Uninstaller very useful in this case. Its free version is sufficient for personal use.

The best part is that it creates a Windows restore point, so there is no fear of losing any other data.

Download link:- https://www.revouninstaller.com/revo-uninstaller-free-download/

Unit testing with xUnit: Introduction

Ravikant Vijayvargiya — Sun, 08 Sep 2024 11:59:30 +0000

Wolf Fact: That's how a pack of wolves sound

Xunit.net is a free, open-source, community-focused unit testing tool for the .NET Framework.

Let’s go. Please visit this link for the code.

Create a .NET console app ( for simplicity) and add an xUnit test project to the solution. Now, we have two projects in the solution — one for application logic and another for unit testing.

xUnit Test Project

Solution XUnitTesting hierarchy

We should always keep the application code and its tests in separate projects.

Application- This project has our application logic.
Application.Test- As the name indicates, this project has test cases for the application code.

I wrote a simple method to divide two numbers in Logics class.

The access modifier for the method must be public. The xUnit checks all methods in all public exported classes in the assembly.

Now we will test this method. We will write unit tests for this method in the UnitTests class.

Don’t forget to add the Application project reference to the Application.Test project.

Fact-

UnitTests.cs TestDivide()

[Fact]: Marks a test method
Assert: The assert class contains various static methods. These methods are utilized to evaluate the testing conditions. Example:- Assert.Equal(expected value, actual value), Assert.True(boolean condition)and many more. You can check all assert statements here.

We pass parameter values for the method and then compare the actual and expected values. In the TestDivide() method, we pass parameters as 4 and 2 for the numerator and denominator respectively.

We can run tests using Test Explorer.

Test Explorer

Our test case passed for the numerator 4 and denominator 2. It would fail for numerator 1 and denominator 3.

We need to improve this test’s coverage. We should specify the precision in the assert statement.

Assert.Equal(expected, actual, precision)

Precision: Verify up to digits after the decimal

There is a drawback to writing test cases like this. We have to create different test methods for various inputs.

Theory-

xUnit theory overcomes the above drawback.

TestDivideMultipleInputs

[Theory]: Marks a test method as being a data theory. A theory is a test case with multiple intakes.
[InlineData]: To provide data for theory.

For an InlineData row, the test method executes one time. So the method TestDivideMultipleInputs will be executed three times. We can provide input parameters and desired output for the divide method using InlineData.

Exception-

This testing tool does not address exceptions with the general assert statements. It uses Assert.Throws. It validates that the exact exception is thrown and not a derived exception type.

TestDivideByZero()

For a zero denominator, the code will throw a DivideByZeroException. The TestDivideByZero() test method validates it. You may try different types of exceptions to verify.

Any feedback would be greatly appreciated. Thank you.

Roadmap to becoming an ASP.NET Core developer

Ravikant Vijayvargiya — Fri, 06 Sep 2024 13:57:00 +0000

I found this cool roadmap to becoming an ASP.NET Core developer by Moien Tajik.

You can find the road map here.

Hopefully, He will maintain this repo but I am still adding my fork in case... here

Moien Tajik LinkedIn

What do you think about this roadmap?

All AI engines in one place

Ravikant Vijayvargiya — Thu, 05 Sep 2024 12:05:00 +0000

https://you.com/

You.com is an innovative search engine.

You.com supports a variety of advanced AI models, allowing users to choose from different options for their conversational and task-oriented needs. Here are some of the key models available:

OpenAI's GPT Models: You.com includes access to OpenAI's GPT-4 and GPT-4 Turbo models, which are known for their high performance in natural language understanding and generation tasks.
Anthropic's Claude Models: This includes Claude Instant, Claude 2, Claude 3 Opus, Claude 3 Sonnet, and Claude 3 Haiku. These models are designed to provide conversational capabilities and are tailored for various applications.
Google's Gemini Pro: This model is part of Google's AI offerings and is designed to enhance conversational AI experiences.
Zephyr: An uncensored model that provides a different approach to AI interactions.

You.com allows users to toggle between these models using a Custom Model Selector, enabling a flexible and tailored experience based on user preferences and specific tasks.

Disclaimer: The content of this post has been generated using You.com

Brave Browser: with built-in Ad-blocker

Ravikant Vijayvargiya — Wed, 04 Sep 2024 13:31:00 +0000

Brave Browser

Privacy and Ad-Blocker

Brave browser has an inbuilt Ad-Blocker so we don't need any extension. It's like YouTube Premium without YouTube Premium, for music and videos.

It also has a Brave shield that can be used for advanced controls like blocking fingerprints and blocking third-party cookies.

Brave shows trackers and ads blocked on a site, like 10 in the above image.

It also displays the total number of trackers blocked till now.

Background Image

Brave has beautiful background images created/captured by various contributors. It makes the browser less boring.

Brave has some awesome features in its mobile version.

Settings -> Media

Background Play

We can play videos on a Mobile device even when we are not using the Brave browser or our phone screen is off.

Block YouTube shorts

It disables the Shorts feature on YouTube.

In-Memory Database with SQLite

Ravikant Vijayvargiya — Sun, 01 Sep 2024 07:19:08 +0000

Wolf Fact: With 200M+ olfactory cells housed in the nose, a wolf’s sense of smell is their most acute. By smell alone, wolves can locate prey, family members, or enemies. They can also tell if other wolves are nearby if they're male/female, etc.

Prerequisites: C#, Visual Studio, basic concepts of database, Web API

What is SQLite? How to install SQLite? How to create a database with it? Why do we need an in-memory DB? And how create it with SQLite?

SQLite: SQLite is a C-language library that provides a SQL database engine that is small, fast, self-contained, high-reliability, and full-featured. SQLite database files are commonly used as containers to transfer rich content between systems and as a long-term archival format for data. SQLite uses dynamic types for tables. It means you can store any value in any column, regardless of the data type.

Install: You can install SQLite from here. I am using Windows, so I used SQLite-tools-win32-x86–3380300.

For Windows

You should choose one based on your OS. You should see the following three files after extracting this zip.

Create a database:

Open command prompt(cmd)

To create a new database

sqlite3 DBName.db
To see a list of the existing databases

.databases

A database with the name localDB.db

What is an In-Memory Database: The data in a traditional database is stored on disk. When the data is needed, it’s called into the local system memory — or RAM — and then is processed by the CPU. Because it takes time to search for data that resides on disks, bottlenecks frequently occur.

In contrast, an in-memory database stores data directly in system memory, plugging directly into the high-speed, low-latency memory bus. It decreases data latency by reducing the time needed to analyze data. With an in-memory database, data is accessed much quicker, allowing you to analyze large volumes of complex data in real time.

When should you use it? An In-memory database uses RAM for storage, resulting in faster read-write operations. You should consider an in-memory database if

The target system has data to manage, but no persistent media.
The performance requirement simply cannot be met with a persistent database

There are a few common examples in which an in-memory database can be useful.

Caching: You can increase performance by using a small in-memory database( can lose data) with a large disk-based database( reliable).
Batch Write: You can perform a batch of read-write operations on the in-memory database. You can back up this database to a physical database after a predetermined period( like 10 mins) or a predeﬁned number of operations( like 5000 queries), as needed.

Now let’s write some code.

We have created a physical database “localDB.db”. Now we need to add a table to this. We can do this using a query or manually using the UI. I am using DB Browser for SQLite to perform operations on the database. DB Browser for SQLite (DB4S) is a high-quality, visual, open-source tool to create, design, and edit database files compatible with SQLite. You can download it from here.

After installing DB Browser, We should add the “localDB.db” file to this.

To add db file

To access existing DB

Now let’s create a new table in the localDB.

Create Table TableOne(Id INT, Value Text)

Table Schema

In-memory database with SQLite: We will create an in-memory database in three main steps.

Duplicate physical database to in-memory: Copy physical DB schema( like tables ) to in-memory.
Operations on the in-memory database: Read-write operation on the in-memory database.
Back up the in-memory DB to the physical DB: Update the real database with the current state of the in-memory database. It is quite quick.

The complete source code can be found here. Let’s get started now.

Create a Web API.

A simple Web API

Add Nuget package to it.

Microsoft.Data.Sqlite

Solution File Structure( I tried to keep things as simple as possible.)

File Structure

I mainly created three files. Let’s go over them one by one.

IDbHelpers: This interface contains method declarations for acquiring physical and in-memory DB connections.

IDbHelpers

DbHelpers: This class contains implementations for GetPhysicalDbConnection and GetInMemoryDbConnection methods.

DbHelpers

-> dbFilePath: Path to “localDB.db” file

-> GetPhysicalDbConnection(): I set the Data Source to dbfilePath with read-write permissions.

-> GetInMemoryDbConnection(): I set the Data Source to :memory: for in-memory database.

Don’t forget to open the DB connection.

HomeController: The addRow API endpoint is available in HomeController. I’ll insert a row into TableOne using an in-memory database connection.

I am using SqlCommand in this example. You may use other methods like dapper. If necessary, you can additionally add a transaction to this connection.

Now let’s test it.

Swagger

and DB status

TableOne Data

We can see data has been successfully inserted and backed up into the physical database.

Friendly Suggestion: If you face an error during code execution that the Database is locked. Try closing the DB Browser.

Any comments or suggestions would be greatly appreciated.

Microservices: Pub/Sub with Dapr, docker-compose, and .NET

Ravikant Vijayvargiya — Fri, 30 Aug 2024 16:19:09 +0000

Wolf Fact: Wolves and domestic dogs share about 99.8% of their DNA, making them closely related.

Prerequisites: C#, basic of Web API, Visual Studio, Docker Desktop

Publish and Subscribe Pattern:-

It defines brokers, publishers, and subscribers, and how they should interact to create a loosely coupled scalable system. The publisher forwards the content/messages to the broker. And the subscribers get these messages from the broker.

The Pub/Sub pattern can be implemented in a variety of ways. Ex.- The broker may push messages to subscribers or subscribers may have to read messages from the broker. Like this, every step’s process depends on implementation.

The broker determines the type of content that a subscriber will receive. The broker uses message filtering techniques for this. There are two mainstream methods.

Topic-based: It is a name for logical channels. A subscriber will receive all the messages published to a topic based on their subscription. The publisher is responsible for defining the topics.
Content-based: In this case, the subscriber classifies what type of content it will receive. So Subscriber is responsible for defining the constraints.

Pub/Sub pattern makes the application more scalable because publishers are not directly bound to subscribers and the broker deals with message delivery. So publishers don’t have to make any changes for a large number of subscribers. That’s the job of the broker.

Pub/Sub with Dapr:-

Dapr supports pub/sub pattern. In Dapr implementation:-

Publisher: It writes messages to an input channel and sends them to a topic, unaware of which application will receive them.
Subscriber: It subscribes to the topic and receives messages from an output channel, unaware of which service produced these messages.

An intermediary message broker copies each message from a publisher’s input channel to an output channel for all subscribers interested in that message. Dapr provides *a content-based routing *pattern( filtering technique).

Dapr Pub/Sub

The pub/sub API in Dapr:

Provides a platform-agnostic API to send and receive messages. Ex. Windows, Linux …
Offers at-least-once message delivery guarantee. Dapr considers a message successfully delivered once the subscriber processes the message and responds with a non-error response.
Integrates with various message brokers and queuing systems. Ex. Apache Kafka, AWS, Azure Service Bus, Redis streams, and many more. You can check the complete list here.

Default Values:

Message Routing: For message routing, Dapr uses the header value Content-Type as datacontenttype. Any message sent by an application to a topic using Dapr is automatically wrapped in a Cloud Events envelope.

Message Content: For message content, Dapr uses the header value Content-Type as text/plain.The developer can change the content type for the message based on requirements.

Dapr applications can subscribe to published topics via two methods that support the same features:

Declarative: Subscription is defined in an external file( YAML file).
programmatic. Subscription is defined in the user code.

So how does dapr pub/sub work?

The Dapr sidecar of the subscriber service calls the /dapr/subscribe endpoint.
The Dapr sidecar of the subscriber creates the requested subscriptions on the message broker.
The publisher sends a message at the /v1.0/publish/<pub-sub-name>/<topic> endpoint on the Dapr publisher’s sidecar.
The publisher sidecar publishes the message to the message broker.
The message broker sends a copy of the message to the subscriber’s sidecar.
The subscriber’s sidecar calls the corresponding endpoint on the subscriber service then the subscriber returns an HTTP response.

HTTP Response Code
204 Message delivered
403 Message forbidden by access controls
404 No pubsub name or topic given
500 Delivery failed
200 Success

Now Let’s write some code. I will continue with the code that I wrote in the previous article. The complete source code can be found here.

I am using the programmatic subscription approach, the subscription will be defined in the code. My Project ServiceOne will behave as a Publisher and ServiceTwo as a subscriber. I will use the Redis Stream component for the broker.

In both services, NuGet packages Dapr.Client and Dapr.AspNetCore is required.

Startup.cs:-

ServiceOne Startup.cs ( Publisher)

ServiceTwo Startup.cs ( Subscriber)

Add these methods to respective services.

UseCloudEvents(): Dapr uses Cloud event 1.0 for message routing( sending messages to topics and receiving responses from subscribers). So we need this method in both startups.
MapSubscribeHandler(): Map the endpoint that will respond to requests /dapr/subscribe from the Dapr runtime. So needs only in subscription service.

Note: If your service is behaving as both subscriber and publisher then you need to add both these methods to the startup.

2. ServiceOne IDaprClientHelper and DaprClientHelper:-

ServiceOne IDaprClientHelper

ServiceOne DaprClientHelper

This method is only required in ServiceOne (Publisher). PublishToTopicWithDaprClient method has so many concepts. Let’s understand them.

2.1. topicName: The name of the topic. It is a user-defined name.

2.2. data: Data that needs to be published on the topic.

2.3. daprClient: The Dapr client package allows interaction with other Dapr applications from a .NET application. The daprClient is an instance of DaprClientBuilder that would be used to call other dapr services.

2.4. PublishEventAsync: Publish an event to the specified topic.

2.5 pubsubname: It is the name of the pubsub component. This will be used by subscribers to subscribe to a topic. We will see it in the ServiceTwo controller.

3. ServiceOne IServiceTwoHelper and ServiceTwoHelper:-

IServiceTwoHelper

ServiceTwoHelper

PublishMessageTopic calls PublishToTopicWithDaprClient method. In this step, serviceOne( + sidecar) will write a message on the specified topic.

pubsubname: pubsub
topicName: publishmessage
data: Notice that data is passed as an object but not as a primitive data type.

4. HomeController:-

ServiceOne Controller Method PublishMessage

This controller method is used to publish the message to the topic.

ServiceTwo Controller Method PublishMessage

This controller method will receive the message from the broker/topic. Notice the header. The topic has two parameters.

First:- pubsubname. Which is pubsub.
Second:- topicName. Which is publishmessage

Both are the same as PublishToTopicWithDaprClient parameters.

Now let’s update the docker-compose file. I am using Redis streams. So I have added the below-mentioned lines to docker-compose.

Docker-compose.yaml

It defines that we need a service Redis on host port 6379 with any available hostname( I chose redisstate, you may choose based on your preference).

Hey, we have written a programmatic subscription for pubsub. Okk.

Also added Redis service to docker-compose file. Okk.

But how will our services know they need to use this Redis stream? hmmm.

Now let’s do this…

Do you remember the declaration of the component in the docker-compose sidecar?

This folder is used to define the components that can be used. We are going to use redis stream component.

Folder structure

Components Folder

Dapr keeps a YAML file in the components folder to identify the components that need to be used.

pubsub.yaml

This file defines that we are using a Redis component at port 6379. I am using dapr.io apiVersion V1 alpha1. The hostname and port number are the same as the docker-compose file.

Now the coding part is done. So let’s run the code.

>>> docker compose build

>>> docker compose up

With these two commands, our services will be up and running.

Call to Service One PublishMessage

It shows status code 200, Success. You can check the console of ServiceTwo to confirm that the message is published correctly( Because I have written it on the console in the ServiceTwo controller).

Docker Desktop (Two services, their sidecars, and Redis service is running)

Docker ServiceTwo Logs

Correctly Published.

So that’s how we can perform Pub/Sub operation with Dapr, docker-compose, and .NET.

Note: You can check out the complete code here. The first commit has docker-compose configurations, and the service-to-service invocation code. The second commit has an extra pub-sub configuration and the pub/sub code.

Any comments or suggestions would be greatly appreciated.

Microservices: Service-to-service invocation with Dapr, docker-compose, and .NET

Ravikant Vijayvargiya — Fri, 30 Aug 2024 10:04:42 +0000

Wolf Fact: Arctic wolves have white coats all year round. This contrasts with Arctic foxes who are white for most of the year but develop a grey coat in the summer months.

Prerequisites: C#, basic of Web API, Visual Studio, Docker Desktop

Have you heard of microservices or Dapr and want to learn more? Perhaps you’d like to know some code to get started. I can assist you.

Microservices:- It is an architectural style that structures an application as a collection of services that are

Highly maintainable and testable
Loosely coupled
Independently deployable
Organized around business capabilities

Microservice is a way to implement a distributed system. All microservices are distributed systems but all distributed systems are not microservices.

Hey, but why do I need this? The more people work on a deployable unit, the less efficient it becomes. Microservice helps in this case, where smaller teams can work on a single deployable unit. These units may or may not be affected by other units. They communicate with one another through various means. That’s where Dapr comes into the picture.

**Dapr**:- Dapr codifies the best practices for building microservice applications into open, independent APIs called building blocks that enable you to create portable applications with the language and framework of your choice. One microservice, for example, is written in Python, while another is written in .NET. They can also easily communicate using Dapr.

Dapr provides so many necessary functionalities for microservice architecture.

Dapr

In this article, I’ll primarily discuss service-to-service invocation.

Dapr’s service invocation process
Dapr’s service invocation process

Service A makes an HTTP or gRPC call targeting Service B. The call goes to the local Dapr sidecar.
Dapr discovers Service B’s location using the name resolution component which is running on the given hosting platform.
Dapr forwards the message to Service B’s Dapr sidecar (always gRPC calls)
Service B’s Dapr sidecar forwards the request to the specified endpoint (or method) on Service B. Service B then runs its business logic code.
Service B sends a response to Service A. The response goes to Service B’s sidecar.
Dapr forwards the response to Service A’s Dapr sidecar.
Service A receives the response.

There are a few new words like a sidecar. Let’s understand them one by one.

Sidecar:-

Bike with sidecar

In the above image, a sidecar is attached to the bike. Logically, the Dapr distributed application capabilities provider is attached to our Service. That’s why the name sidecar. The Dapr APIs are run and exposed on a separate process ( i.e. the Dapr sidecar) running alongside your application. The Dapr sidecar process is named daprd.

Name Resolution Component:- This component helps in finding the sidecar of the desired service. Dapr provides users with the ability to call other applications that have unique IDs. This functionality allows apps to interact with one another via named identifiers and puts the burden of service discovery on the Dapr runtime.

mTLS Encryption:- Mutual Transport Layer Security (mTLS) is a process that establishes an encrypted TLS connection in which both parties use digital certificates( X.509) to authenticate each other. I won’t go in deep on why we need this. If interested, you may have a look at this Wikipedia article.

In a distributed system, Dapr sidecar architecture helps locate other services, call other services securely, and handle retries in case of temporary service interruptions.

After a basic introductory theory, now let’s do a practical example.
The complete code can be found here.

I would create two microservices(Web APIs) with the names ServiceOne and ServiceTwo.

Basic Configuration:-

ASP.NET Core Web API

Two NuGet packages Dapr.Client and Dapr.AspNetCore is required.

Dapr NuGets for ASP.NET Core

Let’s now create the project ServiceOne with Dapr.

1. Folder Structure:-

(You may keep the folder structure the way you prefer.)

Folder Hierarchy

2. Startup.cs:-

Add Dapr integration. Appending the AddDapr extension method to the AddControllers() extension method registers the necessary services to integrate Dapr into the MVC pipeline.

ServiceOne Startup.cs

3. IDaprClientHelper:-

In this interface, I declared a method definition with the name ResponseByDaprClient. This method’s implementation contains steps to invoke other microservices using sidecar.

IDaprClientHelper

4. DaprClientHelper:-

DaprClientHelper

ResponseByDaprClient method has so many concepts. Let’s understand them.

4.1 httpMethod:- Every API has a unique HTTP request method like PATCH/POST/GET/PUT/DELETE. httpMethod contains this HTTP request method details.

4.2 appId:- Name Resolution Component uses this appId to find and perform service invocation for that particular service. AppId would be mentioned in docker-compose.yaml. I will discuss it later in this article.

4.3 endPoint:- Relative API controller path.

4.4 daprClient:- The Dapr client package allows interaction with other Dapr applications from a .NET application. The daprClient is an instance of DaprClientBuilder that would be used to call other dapr services.

4.5 daprRequest:- A HttpRequestMessage that can be used to perform service invocation for the application identified by appId and invokes the method specified by methodName(endPoint) with the HTTP method specified by httpMethod.

4.6 InvokeMethodAsync:- Perform service invocation using the request provided by request. If the response has a success status code the body will de-serialize using JSON to a value of type T. Other wise an exception will be thrown.

5. IServiceTwoHelper:-

In this interface, I declared a method definition with the name GetMessage. This method’s implementation contains steps to call ServiceTwo’s API named GetMessage.

ServiceTwo GetMessage API Controller

6. ServiceTwoHelper:-

I have injected IDaprClientHelper in this class, so I can use ResponseByDaprClient method for ServiceOne to ServiceTwo communication. ResponseByDaprClient takes three parameters as input.

httpMethod- HttpMethod.Get in this case because ServiceTwo API is a Get method.

appId- “servicetwoapp”, this name will be mentioned in the docker-compose file.

endPoint- “/Home/GetMessage”, it is the address of ServiceTwo API.

7. HomeController:-

Now the docker-compose.yaml file.

docker-compose.yaml

I explained a basic docker-compose file in the first part of this series. So here, I am going to focus on the sidecar part i.e. serviceoneapp-dapr and servicetwoapp-dapr.

image: daprd is just the name of the Dapr sidecar process. There are many published Docker images for each of the Dapr components available on Docker Hub. You may use daprd:latest for the latest release. You should always use fix and stable version for the production environment.
command: It contains a collection of instructions to run a Dapr sidecar.
app-id: ResponseByDaprClient uses this name. The name resolution component uses this name to find the required Dapr sidecar.
app-port: This port number will be the same as an exposed port of service’s Dockerfile.

ServiceOne Dockerfile Expose Port

***components***: It is a configuration that defines which state store to use or which pub-sub to use or which binding to use etc.
network_mode: Using network_mode, I placed two containers serviceoneapp-dapr and serviceoneapp in the same namespace. It means both have the same IP and the same open TCP ports.

Hey, that’s a lot of explanation but does it even works?
Now Let’s test it.

>>>docker compose up

deploying....( wink)

Any application can invoke a Dapr sidecar by using the native invoke API built into Dapr. The API can be called with either HTTP or gRPC. Use the following URL to call the HTTP API:

[http://localhost](http://localhost):<dapr-port>/v1.0/invoke/<application-id>/method/<method-name>

the HTTP port that Dapr is listening on.
application ID of the service to call.
name of the method to invoke the remote service.

Call to ServiceOne sidecar which invokes ServiceTwo

Call to ServiceTwo sidecar

That’s how I accomplished service-to-service invocation using docker-compose, Dapr, and a web API.

Friendly Suggestion: Keep the code for every microservice in a separate repository.

Any comments or suggestions would be greatly appreciated.