July 2011 - Posts

Fixing .NET Configuration Hell with TeleSharp: Authoring Configuration Files

The configuration authoring experience remains one of the main challenges of .NET applications. Every time we need to create a new configuration files, we find ourselves going to MSDN or similar websites and trying to figure out the structure of different configuration sections and the sad thing is that we

DO THIS OVER AND OVER AND OVER AGAIN :(

With TeleSharp, we addressed this problem by introducing the model and the tooling that drastically simplifies the experience of authoring configuration files.

Read More....

Fixing .NET configuration hell with TeleSharp: Versioning configuration sections

Story:Bob is an IT Professional (ITPro) responsible for maintaining dozens of enterprise .NET applications. One day, Bob gets a call informing him that one of the applications he is responsible for have stopped working after some changes in the configuration were applied. After hours troubleshooting the application without any positive results, Bob decides to involve the developers who built the new version of the applications. A few hours later, one of the developers finally finds the configuration sections and component that introduced the. Bob wants to roll back the changes in the configuration file but he realizes that he doesn’t have a copy of the previous file and have to asks the developers to give him a copy of the old configuration file. Bob is very frustrated. Bob HATES .NET.

This story illustrates one of the major challenges that ITPros faced when maintaining .NET applications: Configuration file versioning.

Versioning is one of those aspects that have been long time missing in the .NET configuration experience. Configuration changes are a very intrinsic aspect of the lifetime of .NET enterprise applications. However, for years, we haven’t had any mechanisms for keeping track of the changes of the different sections in a configuration file. This situation has forced developers and IT professionals to established and enforce different processes to control the configuration changes in the different applications in an enterprise.

Read More....

Fixing .NET configuration hell with TeleSharp: Reusing configuration sections

Reusability, or the lack of it, is one of the main problems with the .NET configuration experience. How many times do we find ourselves creating the same configuration sections over and over again as part of our .NET applications? And then when those configuration settings change we have to go change it on 20 different places.

With TeleSharp, we created a simple model that allows you to reuse the same configuration sections across the different components of you r applications. The rule is pretty simple Create it once, use it everywhere.

Read more....

Tellago announces Hermes: A publish-subscribe messaging engine based on HTTP and MongoDB

Today Tellago is very happy to announce the open source release of Hermes, a new publish-subscribe messaging technology based on MongoDB and RESTful Services.

Publish-subscribe messaging mechanisms are a fundamental component of distributed systems. The notion of pub-sub has been around since the very early days of computer science and has become increasingly popular in the last few years with the emergence of internet messaging infrastructures such as Twitter, Facebook, Google’s PubSubHubHub or RSS cloud.

Despite of the popularity of these types of messaging, we still don’t have a native pub-sub infrastructure in the Windows platform. Products like BizTalk Server have enabled pub-sub mechanisms in a very traditional way as part of its infrastructure but haven’t provided a foundation that can be seamlessly used by any .NET application.

Introducing Hermes

Hermes was born as part of one of our recent projects at Tellago in which we needed to provide a high performance, highly interoperable pub-sub infrastructure that could be used in a variety of event-based systems. After our initial release, we decided to refactor and make this technology available to the developer community in the form of an open source package.

Hermes Model

Hermes enables a very simple model to implement the foundation of pub-sub applications. The following figure illustrates the basic of Hermes model.

 Hermes[1]

The current version of Hermes includes the following components:

  • Topics: Topics are a name that categorizes a specific piece of information. Examples of topics could be: Errors, News, Alerts, etc.
  • Publishers: A publisher is an entity that publishes information about a specific topic
  • Subscribers: A subscriber is an entity that is interested on certain information about a specific topic. Subscribers interact with Hermes by creating a subscription which is nothing but filter criteria over a specific topic.
  • Subscriptions: The easiest way to define a subscription is Subscription= Topic + Filter. As simple as that, a subscription gets created by specifying a filter expression over a specific topic. Subscriptions examples could, Critical Errors, or Economy News.
  • Filters: Filters are Boolean expressions that are executed against the messages for a specific topic or topic group.
  • Topic Groups: Topic groups are entities that group different topics under a single name. This allows publishers to distribute information that matches a variety of topics.

In order to enable the interaction between publishers and subscribers Hermes enables a series of APIs 100% based on the concepts of the Representational State Transfer (REST).

  • Subscription Management API: This API will be used by publishers and subscribers to create, renew and manage the different topics and topic groups.
  • Publisher API: Using this API, authorized applications will publish data to specific topics.
  • Subscriber API: This API will be used by subscriber applications to retrieve information from specific subscriptions.

Infrastructure

Hermes was built under a very simple set of principles: simplicity, interoperability and high scalability. We achieved simplicity and interoperability by exposing the Hermes infrastructure through a set of very lightweight RESTFul Service APIs built using the upcoming WCF. In order to achieve our expected levels of scalability we decided to rely on MongoDB as the fundamental message repository for Hermes. The used of MongoDB made it extremenly easy to store, partition and index high volumes of messages for a large number of topics and subscriptions.

Roadmap?

Today’s release is just a small glimpse of what we have planed for Hermes. We have been prototipying a lot of ideas and are also planning to incorporate some of the community feedback. Here are some of the things you can expect to see in Hermes soon:

  • Management Portal: We are planning on enabling the core management capabilities of Hermes through a web interface to make it easier for IT professional to interact with the system.
  • Cloud deployment: Wouldn’t it be cool if we could have the same messaging infrastructure working on-premise and on the cloud? We are planning on enabling Hermes infrastructure on Windows Azure and Amazon EC2.
  • New messaging patterns: We are planning to incorporate new messaging patterns that makes it even easier for applications to interact with each other using pub-sub mechanisms.

How to get Hermes?

You can get Hermes bits and source code in our Github repository. Please give it a try to send us some feedback.

The team behind Hermes is full of very talented engineers like Silvio Massari, Jose Romaniello, Gustavo Machado and Vishal Mody.

Tellago Studios webinar: Introducing TeleSharp

Tomorrow I will be presenting the first webinar about Tellago Studios’ TeleSharp. I would like to keep things very practical and will cover the following topics:

·         Using TeleSharp to keep a catalog of you enterprise applications

·         Centralizing .NET configuration using TeleSharp

·         Reusing .NET configuration sections across your applications

·         Versioning .NET configuration files

·         Modeling dependencies between components and configuration files

·         Centralizing logging and error handling in your .NET applications

·         Application assemblies’ inspection and visualization.

If you are a .NET developer working on enterprise applications, you MUST attend to this webinar. You can register here. Hope to see you there.

Why .NET configuration management sucks and what can you do about it

Configuration management is one of the biggest problems of enterprise .NET applications. Since the first release of the .NET framework, configuration has been the main mechanism used by developers to model aspects of applications in a declarative way.

So what’s wrong with .NET configuration?

Reusability

Read more....

More Posts