Corvalius is looking for a graduate (or next to graduation) Software Automation Engineer to join the team as permanent staff. As an automation engineering you will be designing and implementing automation and verification processes to ensure the Team is as efficient and effective as possible. Helping our team to discover and tackle edge cases that most of the time arise during operation activities and more importantly help the team to optimize their own workflow. The position requires an extensive experience in software development using various mainstream and/or other languages (including scripting languages).

Your Duties and Responsibilities:

• Design, Implement and Evolve tools for use by the software development team. Included but not restricted to:
  • Comprehensive test automation tools, with capabilities to define, execute and analyze test scripts.
  • Rapid deployment and system operation tools.
  • Efficient reporting and analysis of operations data.
• Plan, configure and conduct functional, compatibility, performance, stress and regression test.
• Develop and execute reusable and maintainable test automation scripts and other automated tools.
• Being able to rapidly switch from one project to another and reusing the knowledge acquired.

The position requires the candidate to have proven coding abilities, the ability to express thoughts clearly in English and Spanish (both orally and in writing). Other languages are considered favorably.

It is desirable but not required to have experience in Bamboo or any other continuous integration tools, also Powershell and productive cluster environments. It is also desirable to have  contributed to Open Source, blogs or any other technology awareness activities.

Let us know if you want to apply: info@corvalius.com

In our pursuit of finding passionate professionals, who like us, look forward to building tools that simplify our daily lives, we came across Diego Evin, who has recently joined the Corvalius Research and Development division.

Diego has been specializing on the study and application of Computer Learning technology for the last 10 years, in order to solve problems in the Biomedical and Speech Recognition fields. Therefore, he was an ideal candidate for the Corvalius Research and Development division. Kindly known to us as Labs + Academics.

Diego has a bachelor’s degree in Bioengineering and a PhD in Computer Science. Before joining us, he had a postdoctoral internship at Stanford Research International, and also at CONICET, where he worked at the Sensory Research Lab at the Institute of Applied Neuroscience.

With a great deal of published articles circulating the bioengineering field, his research primarily focuses on automatic speech recognition, monitoring and diagnostics of vital signs and medical images.

Among his main contributions to the technological transfer field are his developments to a sound measurement system for the work place, an automatic speech recognition system, and the development of tools for forensic voice analysis.

In the teaching field, he taught the university level course “Artificial Intelligence and Computer Intelligence” at the Universidad Nacional de Entre Rios (2004-2012) and was also the Professor for the graduate level course “Computer Science and Artificial Intelligence Topics Applied to Biomedical Engineering: Artificial Intelligence Techniques”, which was part of the Biomedical Engineering Masters Program (2011).

Want to join Diego and the rest of the team? Let us know.

Buscamos un Desarrollador.

Buscamos un Desarrollador que sepa como codear.

Buscamos un Desarrollador que sepa como codear aplicaciones web.

Buscamos un Desarrollador que sepa como codear aplicaciones web en ASP.NET MVC.

Buscamos un Desarrollador que sepa como codear aplicaciones web en ASP.NET MVC, que quiera seguir creciendo.

Buscamos un Desarrollador que sepa como codear aplicaciones web en ASP.NET MVC, que quiera seguir creciendo y que no quiera dejar de aprender.

 En fin…

Te estamos buscando.

Mandanos tu CV a info@corvalius.com

Today I want to share our experience on targeting extensions to Visual Studio 2010 and 2012 in the same package.

What do we achieve with this?

• A single .vsixmanifest file.
• A single extension Id
• Publish your extension in a single page of the Visual Studio Gallery

One side effect is that at the end of the migration, you must use Visual Studio 2012. We investigated possible ways to create a version of the solution to be compatible with 2010 as well, in our case, it was not possible for reasons I will describe later.

Ok, too much introduction! let’s go to the first step:

1. Changes in the vsixmanifest file:

When you first open your solution created in VS2010 in VS2012, it will try to migrate the extension project. Some interesting thing I’ve learned here:

• The .sln file is compatible for both Visual Studio versions.
• There is a new version of the vsixmanifest schema, but the migration process won’t attempt to migrate it (that is good because we want our extension to be backward compatible). This is the reason why after the migration, VS2012 can’t open the file with the editor, instead it directly shows you the xml.

Ok, so, in order to let your extension be able to detect VS2012 you have to add this lines in the manifest.

<VisualStudio Version="11.0">
<Edition>Ultimate</Edition>
<Edition>Premium</Edition>
<Edition>Pro</Edition>
</VisualStudio>

of course the actual flavors of VS you support depends on your extension.

2. Split the extension:

After changing the manifest you can compile your extension and see if it works on VS2012. In some cases it should work, but we had problems with the following assembly:

• Microsoft.VisualStudio.ExtensibilityHosting

As we are using MEF inside our extension, we depend on that assembly. The point is you can’t use version 10 inside VS2012, it simply won’t work. Because of this problem, we ended up splitting the projects in the following way.

We keep the extension project (the one that contains the manifest) targeting .NET framework 4.0 which contains only references to assemblies that are compatible with VS2012  and we create two other specific projects:

• Extension.v10 –> .Net 4.0 (this project in our case contains references to Microsoft.VisualStudio.ExtensibilityHosting v 10.0.0)
• Extension.v11 –> .Net 4.5 (this contains Microsoft.VisualStudio.ExtensibilityHosting v 11.0.0)

Some considerations:

• The extension project should contain references to Extension.v10 and Extension.v11 (the key here is to set the property “Reference output assembly” to false so the compile in .Net 4.0 despite Extension.v11 targets 4.5).
• Don’t forget to add references to both assemblies in vsixmanifest

<Assembly AssemblyName="Extension.v10">|Extension.v10|</Assembly>
<Assembly AssemblyName="Extension.v11">|Extension.v11|</Assembly>

3. Dynamic load

When your extension is executing, depending on the Visual Studio version it’s running on, it should load the specific assembly for that version . To do that, ask the DTE about the version. Within your Package class, you can use a code similar to this to complete the job:

private const int MaxVsVersion = 11;

protected bool IsVisualStudio2010
        {
            get { return GetMajorVsVersion() == 10; }
        }

private int GetMajorVsVersion()
        {
            DTE dte = (DTE)this.GetService(typeof(DTE));
            string vsVersion = dte.Version;
            Version version;
            if (Version.TryParse(vsVersion, out version))
            {
                return version.Major;
            }
            return MaxVsVersion;
        }

Finally, load the assembly accordingly

 FileInfo assemblyFilename;
            if (IsVisualStudio2010)
                assemblyFilename = new FileInfo(Path.Combine(packageLocation,"Extension.v10.dll"));
            else
                assemblyFilename = new FileInfo(Path.Combine(packageLocation,"Extension.v11.dll"));

            Assembly assembly = Assembly.LoadFrom(assemblyFilename.FullName);

Then, you can use reflection or MEF to resolve what you need (the following code is an example using MEF)

var catalog = new AssemblyCatalog(assembly);
            var bootstrapContainer = new CompositionContainer(catalog);

            var export = bootstrapContainer.GetExportedValue<IBootstrapper>();
            container = export.GetContainer();

Hope It helps!

Hernán

Invitamos a estudiantes, investigadores y profesionales a participar de la segunda edición de la Escuela Argentina de GPGPU Computing para Aplicaciones Científicas, a realizarse del 17 al 21 de Septiembre en las instalaciones de la Universidad Nacional del Sur, Bahía Blanca, Argentina.

GPGPU Computing es una forma de utilizar la gran potencia de cómputo disponible en las placas gráficas (GPUs) modernas para cómputo de propósito general. Las GPUs modernas son arquitecturas masivamente paralelas que pueden ser considerablemente más eficientes que los CPUs convencionales en cuanto a su relación costo/performance y consumo/performance.

El objetivo de la escuela es proveer un espacio para que las personas están interesadas en el tema puedan aprender de forma práctica sus aplicaciones, y para que los profesionales e investigadores que utilizan GPGPU puedan compartir sus experiencias y resultados.

En esta segunda instancia, el énfasis de la Escuela está en las aplicaciones científicas y el procesamiento de imágenes y video. Se ofrecerá un curso introductorio a programación GPU en plataforma OpenCL, un curso sobre programación de aplicaciones en procesamiento de imágenes y video en plataforma OpenCL, un curso sobre programación de aplicaciones científicas avanzadas utilizando bibliotecas científicas, y un curso sobre multifractales aplicado al procesamiento de imágenes y su implementación en GPU.

La compañía argentina afianza su relación con Microsoft a nivel global incorporándose al Visual Studio Industry Partner Program.

Buenos Aires, viernes, 2 de Marzo, 2012. – Microsoft Visual Studio es la herramienta mas consolidada en el mundo a la hora de construir y probar aplicaciones de software ya sean Web o Desktop. Visual Studio Industry Partner es un programa impulsado por Microsoft desde sus oficinas centrales en Redmond, Estados Unidos. El programa permite a las empresas tener acceso temprano a la tecnología y hace hincapié en la certificación de la calidad contemplando los estándares establecidos por el equipo global de la compañía creadora de Windows.

Codealike es un servicio que provee a los desarrolladores y a sus managers con herramientas para administrar su tiempo de manera mas eficiente en los entornos colaborativos actuales a la vez que permite recuperarse mejor ante las interrupciones, un problema que es responsable de la perdida de, al menos, un mes al año de cada programador.

De esta manera, Codealike se convierte en la primera empresa en la Argentina en acceder a la alianza y en garantizar a sus usuarios la calidad final de su producto.

De acuerdo a Federico Lois, fundador de Codealike: “Al ser parte del Visual Studio Industry Partner Program, podemos acelerar nuestros tiempos de desarrollo al tener acceso temprano a especificaciones técnicas y a validaciones por parte del equipo de producto en Redmond. Al mismo tiempo, garantizamos a nuestros clientes la calidad del producto y nos mantenemos actualizados en el soporte a futuras versiones de Visual Studio”. Asimismo, Sebastian Fernandez Quezada, otro de los fundadores de Codealike remarca la importancia del acuerdo al asegurar que “Existe un grupo de alrededor de 150 empresas en el mundo que forman parte del Programa impulsado por Microsoft entre las que se cuentan IBM, Borland, Intel y HP. Codealike se convierte así en la primera en Argentina y en una de las pocas en Latinoamérica.”. Tom Lindeman, Director del Programa Visual Studio Industry Partners indicó: “Estamos complacidos de que Corvalius se haya unido al Programa VSIP como la primera compañía argentina y de que ayude a profundizar el alcance del ecosistema de Visual Studio a través de Codealike.”.

Este acuerdo se suma al alcanzado en Enero de este año entre Codealike y Microsoft en el contexto de Windows Azure, en donde la compañía local se aseguro acceso a esta plataforma y a los equipos técnicos y de asesoramiento estratégico en Latinoamérica y Redmond.

Codealike es una empresa acelerada por Wayra, la aceleradora fundada en 2011 por el Grupo Telefónica a nivel global.

Para más información, visite: http://www.codealike.com

Contacto de Prensa: press@corvalius.com

Codealike es una compañía de Corvalius.

]]> http://www.corvalius.com/blog/index.php/uncategorized/codealike-primer-socio-de-microsoft-para-visual-studio-en-la-argentina/feed/ 0 http://www.corvalius.com/blog/index.php/press-releases/codealike-the-first-microsoft-partner-for-visual-studio-in-argentina/ http://www.corvalius.com/blog/index.php/press-releases/codealike-the-first-microsoft-partner-for-visual-studio-in-argentina/#comments Fri, 02 Mar 2012 21:06:24 +0000 Sebastian Fernandez Quezada http://www.corvalius.com/blog/?p=582 Versión en Español.

The Argentine company has taken its relationship with Microsoft to an international level, by joining the Visual Studio Industry Partner Program so as to obtain exclusive access to technology.

Buenos Aires, Friday, March 2^nd, 2012. …

ADVERTENCIA: Si no te interesa resolver problemas complejos, trabajar para grandes clientes y construir productos de uso masivo que agregan valor, este post no es para vos.

Estamos buscando desarrolladores con los siguientes conocimientos:

Necesario:

1. Senior en C++ (Demostrable)
2. C#
3. Inglés fluido

A new product based on new technologies, which is integrated to Visual Studio, will help software developers deal with collaboration issues and interruptions.

Buenos Aires, Wednesday, November 17, 2011. - Achieving a productive collaboration and dealing with interruptions is certainly an issue for knowledge workers. When it comes to software development, some metrics indicate that wasted time by an average developer in collaboration issues reaches near 50%, while some other studies show that more than an hour a day is wasted dealing with interruptions alone.

Codealike is a SaaS solution that brings real‐time collaboration into Visual Studio 2010. That means that Microsoft Developers, which are supposed to be near 2 million, will have better tools when dealing with interruptions and collaboration issues. Codealike includes features like instant messaging, an integrated searching tool, post and reply Q&A, a timeline that helps understand changes in the source code and, most important, Live collaboration in the source code. This last feature enables multiple developers participate, through Internet, in the same piece of code, at the same time.

According to one of the founders:

“Codealike seizes the Visual Studio context and only with that, developers can find answers to their questions in a way that really fits their needs. As we can also let the developer find other developers with the same interests, we encourage the user to enjoy the likelihood of obtaining qualified help”.

While the founders expect to hit the market in March with the full service, as from Monday they will be giving a limited amount of pre‐release all‐access passes to early subscribers. Good news includes also Microsoft MVP users, who will get the service for free in its premium version for an unlimited period of time.

Codealike is based on two technologies developed by Corvalius: beWeeVee SDK, which allows .NET developers to integrate live collaboration to any software, and eAuth, a SaaS that enables social sign‐in in Desktop and Web‐ based applications.

Codealike is an Startup accelerated by Wayra, the Latin‐America oriented accelerator founded this year by Telefónica.

More information at: Codealike Web Site

We would like to let you know that we’ll launch Codealike really soon (formerly known as Beweevee for Visual Studio). This new version will include new features that we came after considering users’ feedback and use while we were in Beta stage.

Codealike will be FREE for all Microsoft MVP, forever. So, let them all know the good news.

And if you’re not a Microsoft MVP, you can get early access to all of our new features if you register now.

Well, that’s pretty much it.

Feel free to register in: http://www.codealike.com and be ready to build a community around you.

En Corvalius estamos creciendo. Y estamos creciendo como nos gusta hacerlo.  Vos podés ser parte de este crecimiento, acompañándonos en el desarrollo de uno de nuestros productos.

Si pensás que la tecnología es un medio para conseguir grandes cosas y no un fin en sí mismo, entonces podemos hacer grandes cosas juntos.

Estamos buscando desarrolladores con los siguientes conocimientos:

Necesario:

1. WPF
2. C#
3. Windows Azure (Instances and Roles)
4. REST Services
5. Bullshit free

Deseable: 

1. Visual Studio Extensions
2. RavenDB
3. Facebook API
4. Integración con medios de pago digitales.
5. oAuth

http://www.disenoinclusivo.org.ar/2011/09/convocatoria-a-charlas-y-talleres/

El evento, organizado por el Movimiento de Diseño Inclusivo, se realizará el día 8 de noviembre de 2011 en la Escuela Multimedial Da Vinci de la Ciudad de Buenos Aires. Estará orientado a diseñadores y desarrolladores de todos los ámbitos, gerentes de proyectos, instituciones educativas, asociaciones de accesibilidad, profesionales y estudiantes.

Las charlas y talleres deben motivar y brindar herramientas a los participantes para que logren incorporar la usabilidad, accesibilidad y experiencia del usuario en los procesos de diseño de interfaces en los que intervengan durante el ejercicio de su profesión.

Quiero ser expositor en el evento. ¿Qué hago?

1. Enviás una propuesta (1 ó 2 páginas) sobre el tema que te gustaría presentar a convocatoria@disenoinclusivo.org.ar.
   Puede ser una charla, un taller práctico u otra forma de comunicar tu idea al público.
2. Los jurados votan entre todas las ideas presentadas.
3. Si tu idea es una de las seleccionadas, te pediremos que envíes la presentación ó soporte que utilizarás para tu charla o taller.

Ya estamos recibiendo propuestas para las charlas y talleres. La fecha límite de entrega será el viernes 7 de octubre de 2011.

Si tenés material que creas que está bueno para compartir, ¡mandanos tu idea!

El Movimiento de Diseño Inclusivo está formado por miembros de la Asociación de Profesionales de la Usabilidad (UPA Argentina), la Asociación de Diseño de Interacción (IXDA Buenos Aires), The Internet Society (ISOC) y profesionales independientes.

I use to take a random book from my bookshelf and open it at a random page and read from there just a couple of pages. I did that today and it just happen that found a very interesting paragraph in the book “The Pixar Touch. The making of a Company.” written by David A. Price. It’s not a secret that we admire very much Pixar’s work at Corvalius. And it’s no a secret that we strongly believe in technology as a means and never an end itself. Well… it’s curious (at best) when you randomly found this:

(Steve) Jobs enjoyed a reputation as a visionary reader of consumer markets, a reputation he had earned time and again. Yet if he had posessed the same eye for reading individual human beings, he might have noted something unsettling about the men he had just taken on. He might have observed that (Edwin) Catmull and (Alvy Ray) Smith – the chief technical officer and the vice president, respectively, of his new computer hardware company- had no particular interes in computer hardware. For them, computers were simply boxes, the means to an end. If it made the most sense to get a job done with a Sun, or a VAX, or a borrowed Cray, that was the machine they used for.

Picture by Norke

        private int myProperty;
        public int MyProperty
        {
            get { return myProperty; }
            set
            {
                myProperty = value;
                this.Notify("MyProperty");
            }
        }

Several other ideas have been implemented in frameworks like Caliburn and MVVM Light where we gain typesafe and refactoring friendly property notification using lambda expressions. A very clever trick I might say. However, IMHO the property definition syntax is still unnatural and unclear. In short a mess .

        private int myProperty; 
        public int MyProperty 
        { 
            get { return myProperty; } 
            set 
            {
                myProperty = value; 
                this.Notify(() => this.MyProperty); 
            } 
        }

A potential partial solution to this problem came with C# 4.0 with its ExpandoObject or dynamic objects in general. With them we can construct a very simple syntax at the expense of tying ourselves to a base class through inheritance (nothing we are not doing anyway with almost any INotifyPropertyChanged solutions).

        public string MyProperty 
        { 
            get { return (string)this.Storage.MyProperty; } 
            set { this.Storage.MyProperty = value; } 
        }

That is achieved through the following base class definition:

    public class SimpleNotifyPropertyChangedBase : INotifyPropertyChanged 
    { 
        public event PropertyChangedEventHandler PropertyChanged = (s, a) => { }; 

        protected dynamic Storage { get; private set; } 

        
        protected SimpleNotifyPropertyChangedBase()        
        {            
            Storage = new ExpandoObject();            
            var asNotificable = (INotifyPropertyChanged)Storage;            
            asNotificable.PropertyChanged += (sender,arg) this.Notify(sender, arg);        
        }        
        
        protected void Notify(object sender, PropertyChangedEventArgs args) 
        { 
            PropertyChanged(sender, args); 
        } 
    }

This base class is actually a simple implementation that do not support almost any of the features that advanced frameworks like Caliburn.Micro or MVVM Light provides but it is simple enough to demonstrate how to implement it in there too.

On the practical side, the downside we found of using an ExpandoObject is that all properties must be defined prior to use them (in the constructor). Even though, that requirement could be easily lifted reimplementing our own ExpandoObject with a DynamicObject and returning default(T) if the property is not found; the exception is very useful as it allows to discover potential defects in our code.

Hope it is of use,
Happy Coding!!
@federicolois

In this blog post I will show the way I found to do it, it may not be the best, but at least works

First you will need this 2 services:

        [Import]
        private ITextDocumentFactoryService textDocumentFactory;

        [Import]
        private IVsEditorAdaptersFactoryService adaptersFactory;

You will also need a RunningDocumentTable

#region Implementation of IPartImportsSatisfiedNotification

private RunningDocumentTable runningDocumentTable;

void IPartImportsSatisfiedNotification.OnImportsSatisfied()
{
   var serviceProvider = ServiceProvider.GlobalProvider;
   this.runningDocumentTable = new RunningDocumentTable(serviceProvider);
}

#endregion

I have created a HierarchyItem to isolate the needed functionality but works the same if you have the IVsHierarchy and the ItemId.

public bool TryGetTextDocument(HierarchyItemIdentity identity,
                               out ITextDocument document)
{
   foreach (var documentInfo in runningDocumentTable)
   {
      if (documentInfo.ItemId == identity.ItemId &&
          documentInfo.Hierarchy == identity.Hierarchy)
      {
         var legacyBuffer = documentInfo.DocData as IVsTextBuffer;
         if (legacyBuffer != null)
         {
            var buffer = adaptersFactory.GetDataBuffer(legacyBuffer);
            if (buffer != null)
            {
               ITextDocument result;
               if (textDocumentFactory.TryGetTextDocument(buffer, out result))
               {
                  document = result;
                  return true;
               }
            }
         }
      }
  }

  document = null;
  return false;
}

public bool TryGetTextDocument(HierarchyItem item, out ITextDocument document)
{
    return TryGetTextDocument(item.Identity, out document);
}

Voilá, it returns the ITextDocument. The shortcomings of the approach is that you have to checkout every single document opened in the RunningDocumentTable to do it.

Greetings,
Federico

Ahí estuvimos presentes con dos charlas. Aquí el material prometido sobre cada una. Y, como siempre, quedamos a su disposición por cualquier consulta que tengan. Comenten aquí mismo su opinión sobre el evento y sobre nuestras charlas!!

11:40 – Keikendo: WPF Jutsu!

14:30 – Observando lo observable (de T)

Le damos las gracias a Daniel Iglesias de Huddle Group por acompañarnos y por hacer única la sesión.

Abrazos!

Finalmente, el próximo Sábado 4 de Septiembre tendrá lugar la edición 2010 de CodeCamp. Según los propios organizadores, CodeCamp es:

…un evento que reune a Estudiantes, Profesionales y Empresas del área de Informática, realizado por Microsoft, Universidades y ASP.Soft desde el año 2007.

Edición tras edición, queda claro que el evento es mucho más que eso. CodeCamp se erige como el evento más interesante para la comunidad académica/informática. Año tras año se enriquece la convocatoria, el interés y las agendas.

Es difícil condensar en una sola jornada los más interesantes temas y oradores de la comunidad Microsoft local. Difícil, pero no imposible, ver para creer.

El aporte de Corvalius a CodeCamp

En la edición 2010 de CodeCamp, también diremos presente. Y estaremos allí aportando dos charlas:

A las 11:40: Keikendo – WPF Jutsu!

Los equipos de desarrollo se enfrentan con limitaciones que impiden que alcancen su eficiencia máxima a la hora de Diseñar la Experiencia de sus usuarios. Keikendo (del japonés “camino de la experiencia”) es un proceso de capacitación que permite a los equipos incorporar al usuario en toda la estrategia de desarrollo. La charla se orientará a el workflow de desarrollo en WPF, pero las técnicas pueden ser aprovechadas en otras tecnologías ricas o de desarrollo web.

Allí estaremos Federico Lois y Sebastián Fernández Quezada por Corvalius y Santiago Bustelo por Icograma.

Más información sobre Keikendo: www.keikendo.com

A las 14:30: Observando lo Observable (de T)

Haremos una introducción a Reactive Framework y programaremos en vivo una pequeña aplicación con el objetivo de demostrar como es posible simplificar el código de aplicaciones Silverlight 4 y el manejo de operaciones asincrónicas. Se asumen conocimientos mínimos sobre el patrón Model-View-ViewModel.

En esta charla repite Federico Lois y se suma Daniel Iglesias de Huddle Group.

Concluyendo…

No queda más que recomendarles que asistan al evento y que se den una vuelta por nuestras charlas. Y si no es posible verlos en nuestras sesiones y asisten a CodeCamp, estamos seguros de que eligieron bien, porque no es posible elegir la charla incorrecta con la agenda que presentan este año los organizadores.

Para finalizar, les dejamos algunas fotos de la edición 2009 de este evento.

Saludos a todos y nos vemos el Sábado!

PD: Vuelvan al Blog la semana que viene, que publicaremos el material de esta edición.

We have released the Beweevee for Visual Studio 2008 Beta.

New Features

• After usage feedback we incorporated a more developed graphic interface.
• The peer-to-peer networking stack had improved connection stability.
• We improved Visual Studio 2008 general stability issues that arrised on Alpha.
• Network Troubleshooter will be able to pinpoint problems in network connectivity.
• Much faster connection for remote files.
• Facebook Support
• Much improved responsiveness and sign in experience.

Known Issues

The following is a short list of limitations, known issues that you will find while using the product, if you find anything new please report it so we can fix them.

• Close Visual Studio before running the installer.
• The files that maybe shared must be compound only by text, please, don’t share files with graphic components. If some file types has been restricted just let us know and we can test them for the next update.[/i]
• Due to technology connectivity is based on IPv6, if you haven’t an IPv6 network, then we use an IPv4 bridge technology provided by the Operating System that requires that Windows Firewall is ON.
• The User Interface and Workspace Sharing Methods are still in development, the final design will be modified according to our clients usage feedback.
• In the case of Cone NATs the connectivity is limited; you will only be able to connect to workspaces created by others. Note: If you have already connected to a peer, then connectivity is bidirectional.

Installation Instructions

• Step 1: Create and activate your account in https://visualstudio.beweevee.com/Account/SignUp
• Step 2: Download and install the Add-In that you’ll find here: https://visualstudio.beweevee.com/Home/Download
• Step 3: Now you may open Visual Studio 2008, log in through Cooperation Explorer (View Menu) and share files

This is a realtime collaboration oriented moderated forum, so topics are restricted to Beweevee products only on labeled forums, please use the Realtime Collaboration Forum instead to broader realtime collaboration issues. As is common in moderated forums, normal ettiquete rules apply and moderators can edit, review or delete offending posts or users.

You can access to the forums in http://www.beweevee.com/forums 

We would like you to enjoy your stay.

• Silverlight Sketcher
• Silverlight & Javascript Interop
• WinForms Text Editor (client-server)
• WPF Text Editor (client-server)
• WPF Text Editor (p2p)
• Messaging Server (Silverlight 3)

You can start with any of the samples to develop your own Live Collaboration application. You’ll also find a much more simple and commented code so you will be able to code faster with beWeeVee.

Ready to begin? Download beWeeVee SDK v1.0 (Direct Download)

Features

• API for .Net to include live collaboration features.
• Conflict-free Data Synchronization through Operational Transformation.
• Native API Support for Simultaneous Text Edition.
• Extension model for the beWeeVee API base classes.
• Support for Client-Server and Peer-to-Peer architectures.
• WPF and Winforms technology samples.
• Javascript/Silverlight interoperation example.
• Microsoft Peer-Networking (P2P) technology samples.

In the last months, the team of specialists from Microsoft Sharepoint at Huddle Group, worked to integrate beWeeVee as a webpart in this tool. This is a big step because this provides strong progress in the sense of increasing the adoption of co-operation in a corporate environment through familiar tools for these users. Taking its intrinsic benefits to end users in a simple and proven effective.

Huddle Group team, headed by Daniel Saad, based its work on beWeeVee SDK to create a webpart that would easily integrate with Microsoft Sharepoint and export the result of the pad to a Document Library.

How does it works?

1. It allows to write documents using the co-operation between 2 or more users.
2. Automatically saves the result to a Document Library.
3. It uses native Microsoft Sharepoint features such as versioning, workflows, and permissions.

The team developed this webpart to be used in areas such as:

• Meeting Minutes Generator
• Review Spaces for Documents
• Templates for spaces of co-operative working

Another good news is that the webpart works in Microsoft Sharepoint 2007 and Microsoft Sharepoint 2010.

The following is a preview of the product, implemented at a domestic site Huddle Group.

For further information about this product, please contact info@huddle.com.ar

En los últimos meses, el equipo de especialistas de Microsoft Sharepoint en Huddle Group, trabajó para integrar beWeeVee como un webpart en esta herramienta. Este es un gran paso, ya que este avance aporta fuértemente en el sentido de incrementar la adopción de la co-operación en un entorno corporativo a través de herramientas familiares para este tipo de usuarios. Llevando sus beneficios intrínsecos a usuarios finales de manera simple y probádamente efectiva.

El equipo de Huddle Group, a cargo de Daniel Saad, trabajó basándose en el SDK de beWeeVee para crear un webpart que permitiera integrarse fácilmente en Microsoft Sharepoint y exportar el resultado del pad a una Document Library.

¿Cómo funciona?

1. Permite escribir documentos haciendo uso de la co-operación entre 2 o más usuarios.
2. Automáticamente salva el resultado a una Document Library.
3. Utiliza características nativas de Microsoft Sharepoint, tales como versionado, workflows y permisos.

El equipo desarrolló esta webpart para ser utilizada en aspectos tales como:

• Generador de Minutas de Reuniones
• Espacios de Revisión de Documentos
• Templates de espacios co-operativos de trabajo

Otra buena noticia es que el webpart funciona en Microsoft Sharepoint 2007 y en Microsoft Sharepoint 2010.

La siguiente es una vista previa del producto, implementado en un sitio interno de Huddle Group.

Por cualquier información sobre este producto, pueden contactarse a info@huddle.com.ar

Given that Etherpad was bought and shutdown by Google, Etherpad users are now looking for alternatives. As the beWeeVee Notepad Techdemo support some of the features that Etherpad had constructed over their 10 months of operations it looks natural that some more users gravitate toward using it as an alternative.

Yesterday, when the word came to us from one of our users, that Etherpad was effectively shutting down on March we recognized that a void was created when more users started to use beWeeVee Notepad Tech-Demo as a substitute for it. beWeeVee as a technology is very important for Corvalius, as such we will continue to provide more features and also enhance our Software Development Kit for developers to create amazing application with it.

beWeeVee from the start has been conceived as a technology aimed at enhancing Desktop applications (like for example: beWeeVee for Visual Studio ) with real-time collaborative features (co-operation). The Tech-Demo aims to show those looking to implement those features in their software what could be possible using the Software Development Kit.

beWeeVee is a .Net technology so for the time being, the beWeeVee Notepad will continue be released on the Silverlight platform.

We would definitely want to hear your feedback and act accordingly on the technology roadmap. Visit us at http://beweevee.uservoice.com/.

Sincerely,
The beWeeVee Team @Corvalius

Here we publish the firsts attempts that we consider when we were looking for our identity… Which one do you like the most? Leave us a comment.

Acá les dejo la presentación que estuvimos exponiendo con Diego Ferreyra @d2f ¡Gracias a los que vinieron! Cualquier consulta que tengan, ya saben, mauro@corvalius.com.

BTW: Be a Weaver

Audiencia
Gerentes de Tecnología, Project Managers, Arquitectos, Diseñadores de Interacción, Desarrolladores

Oradores

Mauro Castagnasso
Fundador & Manager de la División Knowledge de Corvalius

En su carrera trabajó como desarrollador, arquitecto y consultor .NET en Huddle Group. Su principal interés es encontrar formas de acercar la tecnología a la sociedad y hacerla útil para el bien común, ya sea en forma de aplicaciones o de conocimiento. Su pasatiempo favorito es probar toda la   tecnología que pase por sus manos. Desde software en beta hasta Legos programables.

Santiago Bustelo
Fundador y Director de Icograma

Diseñador gráfico recibido en la Universidad de Buenos Aires, donde también ejerció la docencia. Programador desde 1983, tuvo su primer contacto con el diseño de interacción en 1997, diseñando simuladores de negocios. Desde 1998 ha participado en proyectos de diseño y desarrollo web para Argentina, Chile, España, Estados Unidos e Inglaterra. Actualmente dirige el estudio de diseño y desarrollo Icograma, y es el coordinador del grupo local de la Asociación de Diseño de Interacción (IxDA BA).

First session of beWeeVee’s Real-Time Blogging Test.

We are starting… GMT 15:01
Ending time… GMT 16:29

—— Title: What is realtime blogging, and why we should care about it ——

The last months after the arrival of Google Wave, there has appeared lots of ideas on how to use Co-Operation (aka. Real-Time Collaboration). The idea of using the same artifact is quite of natural in the real world, like when writing in a board. However, we get used to the idea of tokenized access (exclusive access) to resources because of artificial restrictions imposed by technology. Why? There are millions of reasons, but we can resume them in 2 simple keywords: complexity and scarcity.

Solving how to access unique resources with writing actions happening simultaneously is indeed a very hard problem, and everyone that has worked in the field have experienced it first hand. We also have scarcity, the idea that you can have as much bandwidth and computing power as you like may have sounded far fetched 5 or 10 years ago. At the time the seeds of blogging and social networks were sowed most wouldn’t think based on those terms. And now a new seed is in the horizon, that is online co-operative services, Twitter is a first step into this space where access is tokenized but you have an stream of data flowing directly to you (the consumer). Other online services are migrating into this always connected, always alive, environment. Mostly because, it is a real-time service that do not differ much, in the sense that the world is still tokenized. That is all the fuzz about Google Wave, Etherpad and other providers of this technology like beWeeVee itself. We are seeing the transition between a tokenized world into a fluid world where access to resources is shared among the participants.

Blogging and news will not be obnoxious to this trend, there are certain aspects that will definitely change but we think is for the greater good. For example, today, we are real-time blogging as an experiment even though you can read this now as a blog post. We know first hand, that this process would cause fear of embarrassment into almost everybody (we do have it too). It is not easy to be exposed in front of an audience, but most importantly like if you where on TV. Blogs do have audiences today, but what if blogging moves into a real-time environment, where you can go and see what the author is doing, what he is writing, what he is deleting, what he is changing? You start to be like a TV watcher reflecting into the character of your favorite actor, you start to understand his writing processed, you can question it, while it is happening. You then are one among others in the audience, and a real-time information source. In the process, we can derive ratings and audience metrics that may guide (or not) the author in his stance.

Other examples, like multi-author blog post, would require writing policies and methodologies on how to write. Some of them, we had experienced first hand. When one writes and the rest correct (what we used today). Or everybody writes, like we use when doing distributed note taking, may be just a couple among other very different methodologies. From the publisher standpoint there are certain qualities like being able to have complex access control and WYSIWYG support, spell checking, etc. But what about the consumer? We think that the most interesting part is, what the consumer gets. If you allow playback of the session, you allow your consumers to see how you get into that distilled experience that they are reading (if they are interested in knowing more). They can see exactly what you wrote, what you left out, and how you modified it. They can have what we call a TiVo for Text. Now, let’s suppose you are reading a masterpiece from a Nobel laureate. Seeing how he wrote it, how he changed the plot multiple times, how he tried out alternate endings, etc. The potential for learning is huge, it is a very experiential way to learn. There is certainly other uses like correcting essays at school, but that is a topic for a different post.

To summarize, blogging and news will probably be affected by the availability of streams of information and technology is already moving to make that happen, whether you like it or not. What we can do with that technology is what really matters. Real-time blogging like in a movie may or may not work, but the potential for experiential learning is here to stay.

Si en verdad buscás hacer aplicaciones de surface computing (multiusuario, reconocimiento de objetos, interfaces 360, multitouch, interacción directa), la respuesta es Microsoft Surface SDK. Con el SDK, formalmente Microsoft Surface SDK 1.0 SP1, vas a obtener todas las herramientas que necesitás para desarrollar, incluyendo referencia de la API, controles (muchas de las aplicaciones demo que se ven en internet solamente usan los controles incluidos), ejemplos de código y una documentación completa). Se puede descargar desde una subscripción MSDN de nivel Registered Partner o superior.

Pero, si realmente lo que querés es hacer aplicaciones multi touch para PCs multi touch de escritorio, lo podés hacer con Windows 7 y WPF. Mientras que en WPF 4.0 (todavía en beta) multi touch será parte de la API (incluyendo gestos y manipulaciones), por ahora en WPF 3.5 se puede desarrollar multi touch con frameworks e interop libraries como este. Es importante remarcar que soporta gestos como pan, zoom, rotate, los que conocimos en la charla de Microsoft Surface, pero no los controles (ScatterView por ejemplo; aunque sí esta disponible para WPF 4.0, código fuente aquí). Acá también hay lineamientos de diseño para aplicaciones Touch. Lo bueno de esto es que no necesitás una subscripción MSDN para empezar a desarrollar, y que una PC de escritorio es mucho más barata que una Surface Unit.

Y aunque termines usando WPF 3.5, ¡No dejes de darle un vistazo a WPF 4.0!

If you actually want to create develop surface computing applications (multiuser, object recognition, 360 degrees UI, multitouch, direct interaction), you should stick to Microsoft Surface. With its SDK, technically speaking the Microsoft Surface SDK 1.0 SP1, you will get all the tools you need to develop, including API reference, cool controls (many demo applications just use the built-in controls), code samples and a complete documentation. You can download the SDK from a MSDN subscription of Registered Partner level or above.

But if, in fact, you want to create multi touch applications for multi touch desktop PCs, you can do that using Windows 7 and WPF. While in WPF 4.0 (not yet released, just beta) the multi touch capability will be part of the API (including gestures and manipulations), right now with WPF 3.5 the multi touch is achieved using custom frameworks or interop libraries, like this. Is important to remark that this library supports gestures like pan, zoom, rotate, the ones we are used with Microsoft Surface, but no the controls (ScatterView for instance; this one is available in WPF 4.0, source here). Also here you can get design guidelines for touch solutions. The good thing is you don’t need to have a MSDN subscription to start coding, and also, a desktop is far cheaper than a Surface Unit obviously.

We had a booth at the event, so feedback started to come pretty fast. Some of the developers there, had already heard about Google Wave; so the concept of co-operation aka “really real-time collaboration” was already understood. From 1500 attendees, only a few knew that there was a company in Argentina that had been pursuing a similar vision, so they were set for a surprise.

Furthermore, a vision where someone can author digital artifacts in co-operation with many peers, through software designed from the ground up to exploit those interactions; was simple to realize when they were able to play with the Notepad Tech Preview at the booth. Definitely it gave a hint of what was going to be expected from our talk about it.

We called the talk “Cocinando una aplicación Silverlight en una hora” (that in english would sounds like “Cooking a Silverlight Application in 1 hour”), that scored another very important point. We were set for a live coding session where we would start the application from the very beginning, aka “File->New Project” and we would end with a beWeeVee enabled application using Model-View-ViewModel in Silverlight 3.

Then we where set for a surprise, the session was scheduled to start after the lunch break at 3:00 PM. When we arrived there at 2:35PM to setup everything, the room was already full. With the help of the organization team, we took out from the room all the extra stuff (like some tables) to make more room; without much success at 2:45PM with the extra room already taken and people already sitting in the floor we had to close the door. To be true, that was a little shocking but it gave us an idea of the kind of feedback we were going to get.

We started from the design and moved through the implementation of the sketching application using MVVM, until we “faked” the synchronization using a single ViewModel in the same instance. It was the time to introduce beWeeVee, the why and how to achieve the co-operation goals. That part of the presentation was fast, but people was also excited. They wanted to know when we were going to release the bits we were using to achieve those results.

The questions regarding the SDK continued after the session at the booth, so we decided to build and release a Community Tech Preview of beWeeVee for everyone to try out. Those are the bits that we used for the CodeCamp demo and presentation with our own internal documentation that we know is a little bit too sketchy, but it shows the most important parts of the API.

In the SDK we had included: Download beWeeVee SDK Community Tech Preview

- beWeeVee API Binaries for .Net 3.5 and Silverlight 3.
- beWeeVee API Documentation in Compiled HTML (.chm).
- “How to write beWeeVee enabled applications in Word 2007 Format” also available on the blog.
- 2 WPF Notepad examples (Server based and P2P -wcf peer channel- based example).
- 3 “Silverlight 3″ examples (including point based sketching, stroke based sketching with server in the same form and stroke based sketching with server).
- 1 beginners very basic WinForm example on how to write your own control with the Low-Level API.

By using the SDK you are agreeing with the TECHNOLOGY PREVIEW LICENSE AGREEMENT found in the License.txt file.

As promised to those attending the session, you can also download in a separate bundle as academic support material from: Download CodeCamp Academic Material

- The CodeCamp MVVM example with “fake synchronization”.
- The CodeCamp MVVM example with real synchronization using beWeeVee.
- The PowerPoint we used at CodeCamp (the PowerPoint is in Spanish, but it has some interesting diagrams of how things look like).

Disclaimer: All background graphics had been used under what we considered academic fair use, with the aim to set the mood of the presentation (and because they allowed to show a more humane — and less technical — theme). If you are the owner and do not consider it fair use, send a mail to info@corvalius.com and we will remove it immediately.

We had setup a forum where you can leave and vote any idea, feedback, comment or bug report at http://beweevee.uservoice.com. For us your feedback is very important.

Happy Coding,
beWeeVee’s Team

Codecamp es un evento gratuito organizado anualmente en el marco del Programa Académico Microsoft que vincula a docentes, alumnos y profesionales de IT.

Con el propósito de generar un intercambio de experiencias, capacitación y promoción de aprendizaje, se dictarán conferencias simultáneas donde CORVALIUS expondrá temas concernientes a las plataformas Silverlight 3 y al nuevo paradigma de interacción liderado por Microsoft Surface.

El encuentro se realizará en la Universidad de Palermo, en la sede de Mario Bravo 1050, el sábado 26 de septiembre de 9:30 a 19:00 hs.
Para mayor información ingresar en http://www.codecamp.com.ar

Acerca de CORVALIUS

CORVALIUS es una empresa que busca generar el cambio, inspirarlo y hacerlo posible tanto en la propia organización como en su entorno.
Tiene por objetivo la adopción de tecnología en sus clientes mediante la creación de productos, propiedad intelectual, tecnología de punta, diagnóstico, capacitación y prácticas de mentoring.

Posee tres áreas que rigen su negocio:

Labs + Academics: Se encarga de generar tecnología y propiedad intelectual que aporte soluciones nuevas a problemas cotidianos.

Tools: Desarrolla herramientas tecnológicas bajo tres pilares: usabilidad, productividad y colaboración.

Knowledge: Destinada a guiar al cliente o empresa hacia la solución de problemas, creando una experiencia de aprendizaje.

Para más información ingresa en http://www.corvalius.com

In the first two articles we explained how beWeeVee works under the hood [1] to create a seamlessly experience developing applications that can synchronize changes on data structures preserving positional intention [2].

We also introduced the ITextView and IElementView<T> client APIs to easy interact with linear data structures (aka Lists of stuff). Linear structures are more common that one may think at first though, so today we will present an example that shows how a linear structure can accomodate pretty interesting behaviors. All these examples, complete with source code will be released at part of the SDK of beWeeVee. We have already send some copies of a pre-CTP to some interested parties, if for some reason you think that it may be interest to you, and want early access to it; just let us know and we can arrange for an sneak peek. 

The sketcher sample explained

The ability to handle text is pretty understandable in itself (even though you can work on more structured things like XML), so we will focus on something a little bit different. We would like to create an application that will be able to show how beWeeVee can handle other not so common and simple scenarios.

Co-operation (aka Real-time Collaboration) is becoming pretty common in web environments, but with beWeeVee all applications can make use of those features; games have been doing it for years in the restricted model provided by the rules of the objects they use. Our rules are going to be simple:

1. When I draw something I want my other party to see the same thing.

2. But if the two of us draw at the same time we want everybody to be able to see exactly the same and be able to operate over it in exactly the same way; there is no room for inconsistency.

With beWeeVee we are able to achieve Convergence and that is the utility of the approach, when Convergence is achieved both of us will see exactly the same outcome up to the underlying representation level in a consistent way.

So if our representation is at the stroke level, we want to ensure that we are always drawing our strokes in the appropriate depth level. As noted before the data structure has to be linearizable, if we treat every stroke as a simple element (note that we can lift this requirement also ) and put the strokes in a list and use the index of the list as the depth cue, we are simply creating a list of strokes.

We have seen before a way to achieve this using the following code:

public class SynchronizableStrokeCollection : ElementView<SerializableStroke>
{
   public SyncronizableStrokeCollection()
   {
      [...]
   }

   public StrokeCollection Strokes { get; set; }
   [...]
}

It is pretty simple to see that the SerializableStroke is our underlying representation, while the StrokeCollection is just a wrapper usable by WPF or Silverlight to perform the drawing on the screen.

But what is a SerializableStroke anyways? An Stroke is defined as a list of points in a 2D space so we can define it as:

public struct SerializableStylusPoint
{
   public double X { get; set; }
   public double Y { get; set; }
}

public class SerializableStroke
{
   public SerializableStroke()
   {
       StylusPoints = new List<SerializableStylusPoint>();
   }
   public IList<SerializableStylusPoint> StylusPoints { get; set; }
}

Adding and removing strokes is as simple as defining Add and Remove methods. We are going to concentrate on the adding because it is the only method provided in the Sample. But removing items is just selecting the appropriate object and well call Remove

We decided to use an InkPresenter that is going to provide use with points created from the mouse.

When we find a MouseDown event we start to create an stroke (a list of points) and when we received the MouseUp we are done with the Stroke.

As we can see in the extract we are providing methods to compose a stroke internally until it is ready to be put in the beWeeVee managed collection.

public class SynchronizableStrokeCollection : ElementView<SerializableStroke>
{
    private Stroke stroke;
[...]

    public void StartStroke()
    {
        // start a new stroke
        stroke = new Stroke();
        // adds the stroke to the stroke collection
        Strokes.Add(stroke);
    }
    public void AddPointToStroke(StylusPointCollection point)
    {
        // checks if a stroke is being created
        if (stroke != null)
        {
            // add a new point to the stroke
            stroke.StylusPoints.Add(point);
        }
    }
    public void EndStroke()
    {
        if (stroke != null)
        {
            // inserts the stroke on the sync list
           End.Insert(stroke.ToSerializableStroke());
            // create the stroke positions
            stroke = null;
        }
    }
}

The most important part in the code is the: End.Insert(stroke.ToSerializableStroke()) statement. In there you can see that we are getting the End Range (a 0 length tracking range that always point to the end of the list) and inserting at the end a Serializable Stroke created from the real WPF/Silverlight constructed Stroke.

When you are adding the element into the stroke you are ensuring that beWeeVee is already tracking the positional information for that element into that position. However there is a very important thing that we haven’t discussed before, how to send out a message to other beWeeVee instances.

BeWeeVee itself prefers to know nothing about how you prefer to communicate with other instances; however, it provides a reference implementation using Protocol Buffers that can be embedded in almost any method of communication; we also provide the ability to serialize with standard binary encoding too (when available).

In this particular example we are using beWeeVee to synchronize 2 copies in the same process so it is as easy as to send the operation into the other instance. This is a pretty simple way to perform demos but a pretty unrealistic scenario; you can find a WCF implementation to the same idea in the SketcherWithDuplexSample with a very simple server. For high throughput you should use TCP sockets implementations or P2P (PeerNetworking) if in Desktop environments for better performance and low latency response. Don’t worry we will post about it soon, and yes, we have a sample covering P2P technologies too. BeWeeVee after all is designed to handle both standard Client/Server and PeerToPeer scenarios.  

The code to perform the reception is the following:

// creates synchronizable collections
var ssc1 = new SynchronizableStrokeCollection();
var ssc2 = new SynchronizableStrokeCollection();

// wires up the synchronization
ssc1.Controller.OnBroadcast += (operationSender, args) => ssc2.Controller.ReceiveOperation(args.Operation);
ssc2.Controller.OnBroadcast += (operationSender, args) => ssc1.Controller.ReceiveOperation(args.Operation);

It is pretty simple to notice that each SynchronizableStrokeCollection has also inherited its own ConcurrencyController. What we do is to cross wire them, when the Controller expects to broadcast an operation we are telling the other one to receive it.

If we want to use WCF instead of memory copy we would be doing something pretty similar. As in our example we are deciding that both parties are running in the same browser instance (for simplicity only) then we have 2 InkPresenters so we are sending and receiving from the Server in different proxies:

client1 = new ServerClient(binding, address);
client1.ReceivedReceived += (s, arg) => ssc2.Controller.ReceiveOperation(DeserializeOperation(arg.operation));

client2 = new ServerClient(binding, address);
client2.ReceivedReceived += (s, arg) => ssc1.Controller.ReceiveOperation(DeserializeOperation(arg.operation));

// wires up the syncronization
ssc1.Controller.OnBroadcast += (operationSender, args) =>
  {
     var buffer = SerializeOperation(sessionId, args.Operation);
     client1.ReceiveAsync(sessionId, buffer);
  };
ssc2.Controller.OnBroadcast += (operationSender, args) =>
  {
     var buffer = SerializeOperation(sessionId, args.Operation);
     client2.ReceiveAsync(sessionId, buffer);
  };

Up to this moment we have seen how to receive an operation and how to broadcast the operation to the other parties, however, nothing have been done to act when remote operations come from the other sites.

To that we are going to go back again to the SynchronizableStrokeCollection as it has the Controller that should be able to act when operations are sent from the outside. The ElementView<T> is already wired to handle the remote operations, but as we want to also perform those changes into the local stroke collection we also need to wire up the OnRemoteOperationReceived event to execute the operation in the StrokeCollection.

public SynchronizableStrokeCollection()
{
   // stroke collection creation
   Strokes = new StrokeCollection();
   // wires up the operation received event
   Controller.OnRemoteOperationReceived += (sender, args) =>
   args.Operation.Execute(Strokes, serializableStroke => serializableStroke.FromSerializableStroke());
}

As seen in this code extract that is pretty simple, however as we are using  SerializableStrokes to bypass the serializable restriction, we must be able to execute the operation on different type of list. For that, we use a special version of the Execute Command that allows us to convert from a serializable version into a WPF/Silverlight native version.

With that in mind you have all the required building blocks to start synchronizing your linearizable data structures.

Special thanks to Daniel Iglesias from Huddle Group because he programmed the first sketcher demo. Moreover if you are here in Argentina, we will be showing an extended version of this example at Buenos Aires’ CodeCamp 2009 next saturday (26th of September). We will start from the classic “New Project” on Visual Studio up to a WCF Server aware implementation running with a custom server. All, except the server, coded step-by-step in 1 hour using Silverlight 3, Model-View-ViewModel and WCF’ duplex channels. So see you there if you are around.

In the first part of this article we have been exploring how beWeeVee works under the hood, as many other frameworks like Google Wave it resorts to an Operational Transformation Framework.

We also talked about linearizable structures, that is the base of the current beWeeVee implementation that will be released in the CTP. Text as we know it easily linearizable, as you can treat each character as an element on a list. Other things require a little more though, but we are going to show how to create a type independent elements list.

We will focus on explaining how to modify the structures using a Range API that is the base of the ITextView and IElementView<T> helpers.

How to use it for ITextView

The ITextView is a high level representation of a simple text document with edition capabilities based on Range primitives. Ranges are primitive types lately popularized by Andrei Alexandrescu at the Boost Conference [1] and are defined as a pair of begin/end iterators that are packed together as a high level entity. Ranges are perfectly suited to handle the signaling process required by beWeeVee, provide a verifiable and extensible API as they allow easy composition and are a superior abstraction.

The current SDK version only supports non-tracking Ranges, so they are invalidated after an editing operation is performed. After any edition operation is performed it will be returned a new Range accounting for the edition operations that were performed.

Let’s suppose that we want to create a Text Document with “ABC” as its content, and then create a range spanning the entire document.

var textView = new TextView(“ABC”);
Range all = textView.CreateRange(0, 3);

Now all is a range that has “ABC” as its content. If we would wanted to create a range that has on “BC” we would have do the following:

var textView = new TextView(“ABC”);
Range partial = textView.CreateRange(1, 2);

Note that we are starting the range at position 1 and giving it a length of 2. Now let’s suppose that we want to add an “X” before the “B”. It is as simple as:

var textView = new TextView(“ABC”);
Range partial = textView.CreateRange(1, 2);
partial = partial.InsertBefore (“X”);

Now the new partial range contains “AXBC” because it has added before “X” so its length is 4 and the start position is still 1. You can also insert at a specific position inside the range with the InsertAt method.

var textView = new TextView(“ABC”);
Range partial = textView.CreateRange(0, 3);
partial = partial.InsertAt (1, “XX”);

The result of inserting “XX” at position 1 of the range starting and 0 with Length equal to 5 is “AXXBC”. You can also shrink or expand the ranges in any direction using the appropriate methods and delete or replacing range content with something else.

On the background, the Range will signal the ConcurrencyController of the TextView of the changes and transform those operations into canonical form to be sent to the other parties.

How to use the IElementView

The IElementView<T> is a high level representation for elements lists similar to the ITextView but allowing any arbitrary serializable type. It also provides a Range based interface to interact with the content.

It’s usage pattern similar to the TextView, but provides the ability to synchronize more complex structures. The biggest advantage is that allows the developer to control the representation and complexity of the information exchange. For example, you can use Silverlight Stroke class (a non serializable type) and create a synchronized data structure with just a few lines of code.

In the SketcherSample, that we will cover in the third part of this series, we will show a sample where you will be able to see how to perform non serializable types’ adaptation and extending the ElementView<T> through inheritance (it can be possible to also use it without inheriting) to create a synchronized drawing pad.

As a sneak peak I think you can fill in the blanks of what it is needed from this simple code:

public class SynchronizableStrokeCollection : ElementView<SerializableStroke>
{
   public SyncronizableStrokeCollection()
   {
      [...]
   }

   public StrokeCollection Strokes { get; set; }
   [...]
}

In the SynchronizableStrokeCollection example we are creating an ElementView with a SerializableStroke that is a wrapper over the Stroke data structure used in WPF and Silverlight. We exposed the StrokeCollection to perform data binding on the InkPresenter that will show those strokes.

You may be asking yourself: “Could it be so easy?”. You will know pretty soon, so stay tuned.

Nuestra participación estará fuértemente vinculada con la difusión de las tecnologías que se vienen en el ámbito de Microsoft, así como también con nuestra presentación en sociedad en el ámbito académico.

Como hablamos en el primer post de esta serie, estaremos participando en dos charlas:

Microsoft Surface

La charla

Microsoft Surface nos acerca al nuevo paradigma de interfaces de usuario, donde las personas y los dispositivos interactuan de forma más natural con el sotware. Te mostraremos como desarrollar aplicaciones para esta plataforma utilizando el Microsoft Surface SDK 1.0 SP1. Exploreramos como responder a objetos fisicos, a gestos y dedos, programar aplicaciones multiusuario y los nuevos desafios que esto trae aparejado.

Los Oradores

“Nicolás Padula es amante de la tecnología en todos los aspectos, hardware, software,  estudiante de Ingeniería en Informática en la Universidad de Buenos Aires y Consultor en Huddle Group S.A. Con mas de 5 años de experiencia en tecnologías .NET, en especial C#, prueba todo framework nuevo que sale a la luz. Ha trabajado en el área de alta performance en bases de datos, aplicaciones 3D con WPF, desarrollo de frameworks y aplicaciones web para publico masivo entre otros. Pragmático por naturaleza, busca los nexos entre la tecnología y la vida cotidiana en todo lo que hace. Nicolas es también socio fundador de Corvalius”

 “Mauro Castagnasso es Desarrollador por elección, estudiante de Ingeniería en Sistemas de Información en la Universidad Tecnológica Nacional, socio fundador de Corvalius y responsable de la división Knowledge. En su carrera trabajó como desarrollador, arquitecto y consultor .NET en Huddle Group. Su principal interés es encontrar formas de acercar la tecnología a la sociedad y hacerla útil para el bien común ya sea en forma de aplicaciones o de conocimiento. Su pasatiempo favorito es probar toda la tecnología que pase por sus manos. Desde software en beta hasta Legos programables.”

Cocinando una aplicación Silverlight 3 en una hora

La Charla

Programaremos una aplicación co-operativa multiusuario usando Silverlight 3 en vivo. Usaremos una arquitectura MVVM (Model-View-ViewModel), Duplex Polling en WCF, LINQ, Canvas y soporte de dibujado de líneas. No se desarrollará el servidor en vivo, pero si se mostrará cómo fue implementado.

Los Oradores

“Daniel Iglesias tiene 29 años y se encuentra finalizando la carrera de Licenciatura en Informática en la UADE, donde además se desempeña como ayudante de catedra en materias referidas a Análisis, Diseño y Programación orientada a objetos. Trabaja en sistemas desde hace 11 años y desarrolla desde hace 15, desde sus comienzos con Clipper 5.2 hasta la actualidad con las últimas tecnologías Microsoft (C# 3.5, MVC, EF y Silverlight 3).
En la actualidad se desempeña como líder de equipo de desarrollo en Huddle Group, donde se encuentra trabajando desde hace 2 años habiéndose desempeñado tanto en tareas de desarrollo como también de consultoría.”

“Federico Lois es Licenciado en Ciencias de la Computación, Socio Fundador de Corvalius y Manager de la División Labs+Academics. Previo a su partipación activa en Corvalius se desempeño como consultor especializado en Arquitecturas de Integración y Diseño de Aplicaciones en Huddle Group. Su interés por los desafíos lo ha llevado a transitar por caminos bastante “coloridos” como el desarrollo de motores 3D, el análisis de imágenes utilizando hardware gráfico y su última locura “beWeeVee”; un framework de desarrollo de aplicaciones co-operativas en algunos aspectos similar a Google Wave. Fanático de los algoritmos paralelos, el TDD y los lambdas. Cuando no está rompiendo todo se lo puede escuchar por los pasillos hablando de fractales, análisis del mercado de valores o el impacto de la neurociencia en la productividad”.

Recuerden

• Nombre del Evento: Codecamp 2009
• Lugar: Universidad de Palermo – Mario Bravo 1050, Capital Federal.
• Costo: Gratuito – Requiere Inscripción, podes hacerlo desde aquí.
• Horario: 10:00 a 19:00
• Cantidad de Charlas: 50
• Cantidad Esperada de Asistentes: 1000

In the process of preparing the SDK for public consumption, I have been writing some stuff that may be of interest to understand how beWeeVee works under the hood.

Overview

The basis of the beWeeVee engine is an Operational Transformation that has been designed to work with standard .Net collections. Operational Transformation (OT) is a technology that allows a wide range of collaboration functions. In short it allows to synchronize shared copies of data structures achieving convergence, no matter how many processes are involved in modifying it at the same time. Typically OT Frameworks are composed of an OT function and a Concurrency Control algorithm that ensure Causality Preservation, Convergence and Intention Preservation (CCI Model).

BeWeeVee achieves synchronization of shared copies using an OT function that is formally proved to achieve convergence and intention preservation and a concurrency control protocol that allows to execute the operations performed over the copies in a P2P distributed system.

The concurrency control algorithm determine:

1. Which operation should be transformed against which causally ready operation,
2. The order of the transformations to be performed,

while the Transformation function define how different operations are transformed.

The basic idea is that given a linealizable data structure, you can signal beWeeVee of any Insert and Delete operation performed over a data structure allowing it to be modified by several parties without violating the CCI model. That frees you (the developer) of ensuring that the data structure of the parties are equal.

BeWeeVee provides a low level API that allows the developer to notify the concurrency control algorithm of the changes (Operations) that were performed externally to the data structure and the Operations that arrive from the external sites. There are 3 types of operations that the ConcurrencyController may know about:

- Insertion operations,
- Delete operations and
- Identity Operations.

The latter is for internal use and really it doesn’t have any use from the users point of view. On the other hand, Insertion and Deletions are the basic operations that in the end allows the shared copies to be synchronized.

BeWeeVee also provides a high level API that provides the ability to create synchronizable lists that perform all the signalling necessary by themselves. The ITextView and the IElementView<T> are those; they are optimized for random insertions and deletions and allows you to handle Text in the first, and any Serializable type in the latter. Other mapping mechanisms to handle non serializable types are also in place.

BeWeeVee supports discrete revisions but the Low Level API provided by this CTP is poised to be deprecated in favor of continuous snapshots and playback abilities. Playback is a feature that allows any party to start from a predefined moment in time and transform back and forth the data structure to see what was the state at any moment in time. The Playback feature API is not being released in this CTP but it is an intrinsic property of how beWeeVee solves the concurrency problem.

How Operations work.

The operations are the basis of the beWeeVee synchronization engine, and as such the building block of any application using the Operational Transformation Engine. For simplicity we are going to do an example based on text (the usual OT example), even though the approach is valid for other data structures, not just text.

Given a text document with a string “abc” replicated at two collaborating sites; and two concurrent operations generated by two users at collaborating sites 1 and 2, respectively. We get:

O1 = Insert[0, "z"] (to insert character “z” at position “0″)
O2 = Delete[2] (to delete the character at position “2″, note that in this case we are deleting “c”)

Now supposing the two operations are executed in the order of O1 and O2 (at site 1). If we execute O1 first, the document becomes “zabc”; when we execute O2 after O1 the operation Delete[2] would delete “b” instead of the generating site intention that was deleting “c”. Therefore O2 must be transformed against O1 to become: O2′ = Delete[3, "c"]. The end result is that the positional parameter is incremented due to the prior insertion of “z” in O1. When we execute O2′ on “zabc” we are deleting “c” and the document becomes “zab”. The OT transformation will adjust the positional parameter of an operation according to the intended effect of the generating site when presented with concurrent operations, so all sites converge and maintain consistency.

The ConcurrencyController’s Low Level API is responsible in beWeeVee of all the housekeeping necessary to perform the required transformations so the developer get notified of the correct operation to perform on the data structure. Luckily for the majority of developer beWeeVee already provides High Level API constructs for text and typed serializable objects lists. Even though creating your own is not that difficult either, full source code for the ITextView and IElementView<T> is provided as examples.

This is the end of Part 1, in the next we will explain what ITextView and IElementView<T> are and how to use it in a simple way.

Es por eso que estamos convencidos que los principales hacedores de cambio sostenible y sustancial siguen siendo las estructuras de educación formal. Aquellas que forman profesionales que emergen al mercado a aportar soluciones. A aportar cambio.

De acuerdo a como lo vivimos en las últimas décadas y con el advenimiento de nuevas carreras, la transición entre academia y práctica profesional suele ser cada vez menos secuencial. El blend entre Academia, Empresa y Estudiante permite enriquecer los tres ámbitos en un continuum que fortalece no sólo a las partes sino a la relación en si misma.

Eso, entonces, no es más que sinergia en su estado más puro. Esa relación circular se multiplica de a miles en todas las Universidades del pais. Afortunadamente en el campo de la tecnología, cada vez es más común encontrar estudiantes que comienzan su carrera universitaria y son acompañados desde el primer semestre por empresas que permiten su desarrollo en la aplicación de prácticas profesionales de manera responsable y que fortalecen su permanencia en la Universidad y el aporte que pueden hacer a ella.

Ese es el caso de quienes formamos Corvalius y encontramos que esa experiencia, si bien árdua, enriqueció y enriquece nuestro paso por las instituciones educativas. Somos firmes creyentes que este tipo de estructuras aportan a las comunidades de múltiples maneras y lo practicamos cotidianamente como los estudiantes de grado, posgrado y docentes que somos.

Corvalius, entonces, pretende establecerse como el eslabón medio entre la academia y el mercado. Buscamos ser una estructura que canalice lo mejor de ambos mundos y sea un híbrido conformado entre ellos. Y buscamos eso en nuestra práctica diaria y no desde la retórica. BeWeeVee es producto de la implementación de modelos teóricos surgidos en papers de investigadores universitarios y llevó meses de investigación para ser posible. Este proceso de investigación llevado a cabo por el Lic. Federico Lois, nuestro manager de Labs+Academics tuvo su momento de exposición al público durante el último Microsoft Research Latin America Faculty Summit 2009.

Este tipo de acciones son las que tenemos planeado intensificar hasta poder integrar Corvalius con las entidades educativas. Y esa misión nos encuentra estos dias nuevamente de la mano de Microsoft, como participantes activos del próximo Codecamp 2009.

El evento tiene como misión, según fuentes de Microsoft:

Fomentar el acercamiento de las comunidades académica y de desarrolladores de la República Argentina a las últimas tecnologías.

Esto se estructura en el siguiente formato:

• de Estudiantes Destacados: Microsoft Student Partners
• de Profesionales en Tecnologías Microsoft.
• ¿Cómo aprovechar al máximo las 50 charlas que más de 50 profesionales y estudiantes darán en un dia?
  • Ese es el dilema al cual se enfrentan los más de 1.000 asistentes que se espera que colmen las instalaciones de la Universidad de Palermo.
  • La temática, sin bien es variada, es al mismo tiempo simple: Se trata de actualizar a la comunidad sobre los últimos avances en las tecnologías Microsoft.

En resúmen

• Nombre del Evento: Codecamp 2009
• Lugar: Universidad de Palermo – Mario Bravo 1050, Capital Federal.
• Costo: Gratuito – Requiere Inscripción, podes hacerlo desde aquí.
• Horario: 10:00 a 19:00
• Cantidad de Charlas: 50
• Cantidad Esperada de Asistentes: 1000

 En las próximas semanas vamos a estar publicando avances sobre las charlas que estaremos dando en Codecamp. Vamos a contarles en detalle sobre la charla de Federico Lois y Daniel Iglesias (Huddle Group) sobre Silverlight 3 y la de Mauro Castagnasso y Nicolas Padula sobre como hacer tu propia aplicación para Microsoft Surface.

Since the last time we did a public update we have added a couple of features, like revisions, colored users and faster response. From the beginning releasing the technical preview was aimed into acquiring hard-data on the behavior of the underlying technology in what we called an “on-the-wild” scenario. Thanks to early users feedback we were able to pinpoint performance issues, understand the features required to make the user experience more humane, and even suggestions on how to better improve the API (some of which didn’t get it into this release).

Serious improvements have been done at the technology level, just to name a few:

- The operational transformation is 68% faster.
- Revisions have been added allowing the users to save snapshots of their work at anytime.
- The bandwidth required to sustain proper operations have been reduced considerably.
- We have fixed some defects involving losing connection with the server after prolonged idle time.

We want to announce too that next week we are going to release a CTP of the core components of the Software Development Kit (SDK) for people that wants to experiment with the API. We definitely want to know what you are doing with it . Another interesting development is that we have finished the proof of concept stage of beWeeVee for Visual Studio and starting on full development in 2 weeks.

You can see the concept work here:

We are extending our thanks also to the development teams at Huddle Group that used beWeeVee first preview when doing real work, the attention to detail of Dayanna pointing out defects and early feedback and Daniel Iglesias for suggestions in improving the API usability. Stay tuned for a pretty interesting demo he is preparing using beWeeVee API and Silverlight 3.0 (yes, beWeeVee is Silverlight 3.0 compliant).

Hope you will enjoy it as we do,
Federico  

[*] You can still access your old documents from http://www.beweevee.com/incrediwrite

As some of you know, Corvalius today is an organization that aim to create and develop technology that makes daily work easier. We are an organization that will take much effort to link the academy with the market. And, of course, hope to make many people a little happier on the road. But it was not always like that. To be fair, at a time it was nothing.

I could tell you about what Corvalius is, what Corvalius is going to do. But no. Today I will try to tell you about what Corvalius is no more. I would like to tell you what it was, and what made possible what it is today. And this is just another arbitrary thing, because it allows us to understand things better. Ie, we will draw a boundary from when all of those that are part of this company could express what we wanted for our future, up to when we started to execute the plans that we develop for more than a year.

In the summer of 2008 I had a realization. I would prefer to accept the consequences of failure than to repress myself of following the impulses of creating my first company. I started the year by laying out some sporadic ideas in a notebook. Without a name, but ideas nonetheless. When these ideas drew a smile on my face, I felt confident to tell them to those who would like to hear it. It seems that I was not the only one …

Corvalius was at the moment nothing else than a set of unsorted ideas in the heads of Mauro Castagnasso, Federico Lois, Nicolas Padula, and me (Sebastián Fernández Quezada). These ideas were difficult to identify clearly, were confusing and resembled more as wishes than ideas. But they were there, since who knows when, but they were ready to reveal themselves all at the same time.

In that coffee, at Corrientes Street, we realized that the first thing we needed was to be able to express easily our Core Values, those that were going to guide us throughout this enterprise. What things would not be negotiable? It didn’t matter the customer set, the offerings nor much less the economic opportunity that would allow us to make the transition.

We where there in a table where the only evidence of a tie between us was, at the moment, a sheet of paper and a pen borrowed from the waiter. With the borrowed pen, each one of us wrote 2 o 3 statements that represented what we wanted for this organization. That very same night, the first email of that group of people had the following text.

(It was in Spanish, so this is a translation)

Guys,

Here I send you the common Core Values that we had defined at the moment. I suggest that our next step is to include some more until Friday and then dismiss the less useful until we can find the 5 invariant ones.

• Being able to inspire, generate and encourage change.
• Accelerate the technology transference phase for the benefits of our clients.

(…)

It is of no interest to me the technology platform we adopt. I care too much, that we could establish an organization that can take a good person and make it better. And in that path, he would be able to pursue unseen, useful, sustainable and SIMPLE ways to solve problems through information systems first, technology later.

The rest, will come easily.

I would like to know what do you think.

By the way… corvalius.com.ar and corvalius.com are free

Best wishes,

Corvalius was born, not only it had a name (thing that was surprisingly easy to find) but it has its Core Values. It had the core that was going to influence the rest that was necessary. That Monday 26th of May of 2008 it was born.

That very same list evolved and became the following:

Core Values:

• Being able to inspire, generate and encourage change
• Being innovation leaders, working toward joining the human and technological factors.

Mission:

Being an organization able to inspire, generate and encourage change. Being able to produce a turning point in our customer’s organization, always aiming to accelerate the transference of technology for their own benefit.

Core Ideology:

• Offer the best solution to our client’s problems, being aware of all possible variables.
• Promote absolute transparency with clients, providers, colleagues and shareholders.
• Embrace simplicity as a key concept at every stage.
• Promote taking independent decisions based on measurable and necessary risk with the objective of achieve innovation and higher quality.
• Have high expectations and low tolerance for poor performance.
• Develop our future leaders and promote from within based on merit, not time in the company.

Business Strategy:

• Embrace simplicity as a key concept at every stage.
• Decentralization and delegation of responsibility.
• Actively ensure discipline in shared resources use and service outsourcing and acquisition.

 

(English translator note: the actual text was a mixture of English and Spanish terms, you can see the original one at the Spanish version of this post).

I wanted to be as faithful as possible and included Federico’s text as is. I think it express clearly a few point .

Being aware at this time that the very same things that we wanted to be inalterable, was the actual thing that allows us to keep momentum is great. Corvalius was gradually taking more and more space in hour heads and hearts… The next day we tried out some isologos, nothing could stop us now:

The 6 initial isologos tried to represent the importance of our core values. That radiate from the center toward the whole. Fortunately for us, these alternatives lasted a very short time. For us, it was always key to represent a solid symbolic image of Corvalius. If we could join and symbolize what we wanted to do, we could communicate efficiently that intend to our clients, collaborators, families, friends, and everybody. We live in an age where information is discarded quickly, we believe in the importance of having a symbol that can create a lasting message in the minds of our audience. We then decided to look for professional assistance in the matter. Our first official version of the isologo was the following:

With it we wanted to simplify the image, but keep the original concept: The nucleus that radiates to the whole.

While we advanced with the image, we started to develop the business. Understand better the market that we were aiming for. Identify our value proposal, comprehend it, express it and make it a viable thing. 10 months we were dedicated to define aspects that included among other things:

• Market segmentation.
• Product Definition.
• Business Units definition.
• Commercialization Channels.
• Communicational Planning.

The main objective of these activities at an early stage, was further strengthening the vision of each of us 4 in relation to the business. Understand the problems that we wanted to resolve, how to provide a solution to the market, the GTM, etc… all in order to better understand what we would keep actually occupied in the coming years.

At some point in defining the foregoing, we understood that our image should be simpler. That it should be tackled under the same simplicity ideals that were influencing the plan and the structure of the business. We understood that an easy to understand, easy to write by hand logo and with internal winks would be much more rich and would represent us better. ZOom helped us to express it. He helped us to understand how to represent our essence in a logo and how to inform the public about it. After few iterations, arose what today is our official logo:

Then it was the time for our isologo. We wanted an image to be the companion our logo, but that could serve us individually as a symbol. With the idea of representing us and what we do. Above all that it represents the work methodology that we had layed out when we defined the operative schema of the company. The hummingbird could represent easily the idea that we wanted to express. That is very tied to our business strategy and the business ecosystem we are in.

There was a moment where we were able to put those desires and ideas into work. We were prepared and it was definitely the key moment to do it. Nothing was forced and it turned out as a pretty natural situation that allows us to order our ideas and define the project. That allows us to know the answers to the questions people outside our close circle of friends could ask. Many questions that we got when we told people in our inner circle of collaborators already had been answered. And the ones that couldn’t, where naturally discussed under the light our Core Values to give them an answer. That is not an small thing. Not only because of the solid image, that is a secondary and natural effect of really being solid; but because it allowed us to construct scenarios of the future, and allowed us to test our assumptions and in the process find the way to construct the scenario that we wanted.

It was at that time, that still being Huddle Group’ employees and nurtured by the culture of the organization, we decided to return to the sources. Temptation to carry the idea and not wait till we have it well defined was always present. But it was important to be able to wait for the appropriate time. To mature our ideas, to test them against reality. Since that time, it was like to convince another partner to join this venture. The open mind found in the persons and organization was as usual. But I think that the crucial difference was having shown it as: “Something that was going to happen” and not “something that would be great to happen”. The team was and is solid, convinced what it want to accomplish no matter what destiny wants to put in front of us. That very same message we transmitted to the board of Huddle Group, and that was the message they received.

The agreement came on May. Exactly 1 year after that very first meeting of the group that today is Corvalius. After many (really lots) of work and discarded ideas, Corvalius is today an spin off of Huddle Group. Its true that when we started to define the company, we didn’t do it with the objective of doing it as an spin off of Huddle, but that alternative was evaluated when we have the entire scope, when we understood that Corvalius was a compatible piece in the puzzle that Huddle Group was immersed. That is quite important, that was going to be of value for both. We are no longer 4, we are 5 now and something really cool is happening.

Here are some concepts that I would like to synthesize and maybe contribute with someone that maybe is in the same situation:

• The importance of tell someone your ideas: In the summer of 2008 there I was, with what I though was an amazing idea. Today that idea is more or less 1% of what Corvalius is. It is 1% of what the rest of my partners and the synergy of working together created. I found that I didn’t tell anybody an idea until I was confident with it or until I found how to make it sustainable; what I missed was that the valuable part was me, not the idea itself. All ideas are replicable and none are patentable (except in certain countries )… What really matters is how to put them in practice, how to understand that unrepeatable component that is embedded in you.
• Associate: I still remember the dissertation of Gabo Nazar in the last Endeavor Conference at Buenos Aires, where he remembered the advises his father gave him encouraging him to work alone and not look for partners. And how doing exactly the same helped him to create “Cardón” and other companies. It’s a common reality. It’s  true that a person that knows how to work alone, logically, can do its work properly. The question that should be done is: “How much better the result would have been if I would have the right partners?” Adding partners to your ventures is going to incorporate uncertainty and the obligation to negotiate, and sometimes yield at some things. But the end result will always be richer. Associate requires equality and symmetry. Develop symmetric relationship that discourage suspicion, where each component is equilibrated is not crucial to have results, but is if you want the relationship to be sustainable in the long run.
• A personal question: One of my best teaching was left by one of my mentors Fernando Grosso, it is that it doesn’t exists a difference between personal life and work. That is a popular myth that must have been eradicated long ago. Corvalius is for us a challenge that we want to achieve in a personal level. And it is far away of the revenue or the quantity of employees that the company might have. Part of the information that we share in our CMS is a list of dreams that we want to personally accomplish through Corvalius (that’s real). Some examples: To work with Pixar or 3M, to advance the state of the art in medicine, to publish a paper in Siggraph, to see the boreal aurora, to write a book, to invent teleportation. The important thing is to be involved with your Endeavour. The second, to be able to say it in the open.
• Clear objectives and focus: Our plan was concise, our proposal to Huddle Group was concise too. We worked very hard to make our desires to be possible objectives. Much effort went in, other was left out. It is pretty important to be able to discard difficult to quantify ideas or impossible objectives to be able to have measurable milestones. The important of focus is that accomplishing objectives you are free, but when you get out of those limits, it forces you to think about what you are doing.
• The future doesn’t come. It is created: Its very important to be aware of this. To take the bull from the horns and being a participant in what is going to come. All the work put in the plan was invested to create a future. Sure… to create a future and its alternatives.

We are going to go deeper on the general things that we tell in this article, mostly because we want to tell news about Corvalius outside from product or offerings that we would be developing. After all one of our values is transparency, so what you cannot see we are going to show by ourselves.

Como algunos de ustedes saben, Corvalius es hoy una organización orientada a crear y desarrollar tecnología que haga más fácil el trabajo cotidiano. Somos una organización que insumirá mucho esfuerzo en vincular a la Academia con el Mercado. Y, lógicamente, esperamos hacer a mucha gente un poco más feliz en el camino. Pero en un momento no era nada de eso. Ciértamente no era NADA.

Podría contarles sobre lo que Corvalius es, sobre lo que Corvalius va a hacer. Pero no. Hoy me interesa contarles sobre lo que Corvalius no es más. Me interesa contarles sobre lo que fue e hizo posible lo que hoy es. Y esto no es más que una arbitrariedad, otra más de todas las que solemos poner las personas para comprender mejor las cosas. Es decir, trazaremos un límite desde que cada uno de los que hoy formamos parte de esta empresa (en el sentido amplio del término), pudimos expresar lo que queríamos para nuestro futuro hasta que comenzamos a ejecutar los diversos planes que desarrollamos durante más de un año.

En el verano del 2008 estaba decidido. Prefería aceptar las consecuencias de fracasar por mi cuenta que seguir reprimiendo los impulsos de desarrollar mi primer compañía. Comencé el año definiendo algunas ideas de manera esporádica en un cuaderno. Sin nombre, pero ideas al fin. Cuando esas ideas me dibujaban una sonrisa en la cara y me sentía con confianza como para contarlas, las contaba a quien quisiera oir. Parece que no era el único…

Corvalius no era entonces nada más que un conjunto de ideas desordenadas en la cabeza de Mauro Castagnasso, Federico Lois, Nicolas Padula y yo, Sebastián Fernández Quezada. Esas ideas eran incluso difíciles de identificar claramente. Eran confusas y hasta parecían más ganas que ideas. Pero estaban ahí, desde hacía mucho tiempo y en algún momento se dieron por salir al mismo tiempo.

En ese café de la calle Corrientes, tuvimos claro que lo primero que teníamos que poder expresar fácilmente y consolidar, eran los Valores Nucleares que nos iban a guiar durante todo el emprendimiento. ¿Qué cosas no serían negociables? No importó la cartera de clientes, ni los offerings ni mucho menos la oportunidad coyuntural que nos ayudaría a realizar la transición entre estados.

Estábamos sentados en esa mesa y la única evidencia de lo que nos unía hasta el momento fue una hoja de papel y una lapicera prestada del mozo que nos fuimos pasando y en donde cada uno escribió 2 ó 3 frases que representaban lo que querían para la organización. A la noche, llegó el primer e-mail del grupo que contenía el siguiente texto:

Gente,

Les paso los Core Values comunes que tenemos hasta el momento. Sugiero como próximos pasos incluir más hasta el viernes y de ahí descartar los menos afines a los 4 para quedarnos con un hardcore invariable.

• Provocar un punto de inflexión en la organización de nuestros clientes.
• Acelerar la transferencia de tecnología para beneficio del cliente.

(…)

Me interesa muy poco la plataforma tecnológica que adoptemos. Me importa demasiado, sin embargo, que podamos establecer una organización que sea capaz de tomar a una buena persona y hacerla mejor. Y en ese transcurrir, aporte nuevas, útiles, sustentables y SIMPLES formas de resolver problemas a través de los sistemas de información primero y la tecnología después.

El resto, creo, viene por añadidura.

Me gustaría conocer que piensan ustedes.

A propósito… corvalius.com.ar y corvalius.com están sin registrar

Un abrazo,

Sebas

Había nacido Corvalius, no sólo tenía nombre (cosa que fue sorprendentemente rápido de conseguir) sino que tenía una identidad nuclear. Tenía un núcleo de valores que iban a generar el resto de lo necesario. Ese día fue el Lunes 26 de Mayo de 2008.

Esa lista luego evolucionó y llegó a ser la siguiente:

Core Values:

- Ser una organización que genere, propicie e inspire el cambio.

- Ser motores de la innovación uniendo el factor humano con el tecnológico.

Misión:

“Ser una organización que genere, propicie e inspire el cambio. Provocando un punto de inflexión en la organización de nuestros clientes. Con el objetivo de acelerar la transferencia de tecnología para su beneficio.”

Core Ideology:

• Hacer siempre lo mejor para nuestros clientes.
• Transparencia absoluta con clientes, colaboradores, proveedores y socios.
• Ejercicio de toda actividad con el foco centrado en la simplicidad
• Alentar la toma de decisiones centrada en la asunción de riesgos necesarios, teniendo como objetivo la innovación.
• Have high expectations and a low tolerance for poor performance (como lo escribimos en castellano??)
• Develop our future leaders and promote from within based on merit, not time in the company.

Business Strategy:

- Ejercicio de toda actividad con el foco centrado en la simplicidad

- Descentralización y delegación de responsabilidades.

- Disciplina en la utilización de recursos compartidos y en la adquisición de servicios.

Quise ser fiel en la copia e incluí el texto tal y como Federico lo consolidó. Creo que expresa cláramente el punto

Ser concientes a esa altura de que lo que cada uno quería que permaneciera inalterable era coincidente fue lo principal para mantener el momentum. Corvalius ocupaba gradualmente más espacio en nuestras cabezas y en nuestros corazones… Al otro día se ensayaron algunos isologotipos, nada podía detenernos:

Los 6 isologos iniciales intentaban representar la importancia de los valores nucleares. Que desde el centro irradian hacia el todo. Por suerte, estas alternativas duraron poco tiempo. Para nosotros, siempre fue clave poder representar una imágen simbólica sólida para Corvalius. Si podía unirnos y simbolizar lo que queríamos hacer entre nosotros, entonces podíamos usarla efectivamente con nuestros clientes, colaboradores, familias, amigos, todos. En la era en la que vivimos, en donde existe cada vez más información que se descarta cada vez más rápido, creemos en la importancia que puede tener un símbolo para ser asociado al mensaje y que de manera residual se vaya fijando a la mente de nuestra audiencia. Fue ahí cuando decidimos buscar ayuda profesional rápido. Nuestra primera versión oficial y profesional del isologo, fue entonces la siguiente:

Con ella quisimos simplificar la imágen, pero mantener el concepto principal: El núcleo que irradia el todo…

Mientras avanzábamos con la imágen, empezamos a desarrollar el negocio. Entender mejor el mercado al que queríamos apuntar. Identificar nuestra propuesta de valor, comprenderla, poder expresarla y hacerla viable. Durante más de 10 meses estuvimos dedicados a definir estos aspectos. Que incluyeron:

• Segmentar el Mercado
• Definir los Productos
• Determinar las Unidades de Negocio
• Identificar los Canales de Comercialización
• Planificar la Comunicación

El principal objetivo de poder desarrollar esas actividades en una etapa temprana, fue el de seguir consolidando la visión de cada uno de nosotros 4 con respecto al negocio. Entender las problemáticas que queríamos resolver, la forma de aportar una solución al mercado, el GTM, etc… todo con el objetivo de comprender mejor lo que nos iba a mantener realmente ocupado en los próximos años.

En algún momento de definir lo anterior, comprendimos que nuestra imágen debía ser más simple. Que debía condecirse con la simplicidad que estábamos logrando en el plan y la estructura del negocio. Comprendimos que un logotipo fácil de entender, de reproducir a mano alzada y con guiños internos, sería más rico y nos representaría mucho más. ZOom nos ayudó a expresarlo. Nos ayudó a comprender nuestra esencia y a comunicarla al público. Luego de pocas iteraciones, surgió lo que es hoy por hoy nuestro logotipo oficial:

Luego, vino el isotipo. Queríamos que una imágen acompañara eventualmente al logo o pueda servir individualmente como símbolo. Como un icono que remitiera a nosotros y a lo que nosotros hacemos. Sobre todo a aquella metodología de trabajo que nos habíamos planteado al definir el esquema operativo de la compañía. La imágen del Colibrí, pudo representar fácilmente la idea que necesitamos expresar. Que resulta indivisible de nuestra estrategia de negocio y de nuestro objetivo en el ecosistema de organizaciones que nos circunda.

Como les conté, hubo un momento en donde fuimos capaces de traducir ganas a ideas. Estuvimos preparados y fue el momento clave para hacerlo. Nada fue forzado y lo natural de los eventos nos permitió fluir hasta poder ordenar las ideas y definir el proyecto. Esto nos adelantó a las preguntas que cualquier persona fuera de nuestro círculo pudiera hacernos. Muchas de las preguntas que recibimos cuando contábamos a nuestros cercanos el proyecto, ya habían sido establecidas y respondidas previamente. Y las preguntas que no podíamos responder, volvían al Core a ser discutidas hasta darles una respuesta. Eso no es menor. No sólo por la imágen de solidez, que es un efecto secundario y natural de realmente estar sólido. Sino porque nos permitió imaginar escenarios futuros posibles, hasta encontrar aquel escenario que queríamos construir.

Fue ahí que, siendo aún empleados de Huddle Group y nutridos de la cultura de esa organización, decidimos volver a las fuentes. La tentación de llevar la idea y no esperar a tener definida una primera versión del proyecto y del negocio siempre estuvo presente. Pero fue importante poder esperar el momento adecuado. Madurar las ideas. Ponerlas a prueba. Desde ese momento, fue como convencer a un socio más. La apertura que encontramos en las personas y en la organización, fue la habitual. Pero considero que fue determinante poder contar un proyecto y no solamente una idea. El equipo estaba sólido, estaba (y está ) convencido del escenario futuro que quiere crear a pesar de los que el destino se empeñe en establecer. Eso mismo se estaba transmitiendo al directorio de Huddle Group, y ese mismo mensaje se recibió.

El acuerdo llegó en Mayo pasado. Un año desde la primer reunión del grupo. Mucho, mucho (realmente mucho) trabajo e ideas descartadas despues, Corvalius se convirtió en el primer Spin Off de Huddle Group. Es cierto que desde que empezamos a definir la compañía, no lo hicimos con el objetivo de desarrollarla como un spin off de Huddle Group. Esa alternativa se empezó a evaluar cuando empezamos a ver el panorama completo y a comprender que Corvalius era una pieza compatible del rompecabezas en donde Huddle Group estaba inmerso. La alianza era natural. Corvalius reflejó siempre desde su concepción, los valores que Huddle Group siempre poseyó. Y eso es importante. Eso iba a fortalecernos a ambos.

Ya no somos más 4. Ahora somos 5 y algo bueno está pasando…

Algunos conceptos que me interesa sintetizar y quizás puedan contribuír a alguien:

• La importancia de contar la idea: En el verano de 2008 estaba yo sólo con lo que creía una idea insuperable. Hoy, esa idea es el 1% de lo que es Corvalius. Es un 1% de lo que el resto de mis socios y de la sinergia entre nosotros generó. Encontré que no contaba una idea cuando no sentía confianza en ella o cuando no la veía como algo sustentable en donde el componente que realmente la hacía valiosa era yo. Todas las ideas son replicables y ninguna idea es patentable. Lo realmente importante es poder llevarla a la práctica y entender el componente que cada uno puede aportar de manera irrepetible.

• Asociarse: Todavía recuerdo la disertación de Gabo Nazar en la última Conferencia Endeavor de Buenos Aires. En donde recordaba los consejos de su padre que lo alentaban a trabajar solo y no buscar socios y como hacer lo contrario lo ayudó con Cardón y otros emprendimientos. Es una realidad cierta. Es cierto que una persona acostumbrada a trabajar bien sola, lógicamente, puede hacer bien su trabajo. La pregunta es: ¿Cuánto mejor podría ser ese resultado si tuviese el/los socio/s correcto/s? Incorporar socios a tu proyecto va a incorporar incertidumbre y la obligación de negociar y ceder en muchos aspectos. Pero el resultado sera siempre mucho más rico. Asociarse requiere igualdad y la simetría es importante. Desarrollar relaciones simétricas, que no generen desconfianza y en donde cada componente aporte equilibradamente no es crucial para que se den buenos resultados, pero es indispensable para que la relación sea sustentable y a largo plazo.

• Es una cuestión Personal: Uno de las mejores enseñanzas que me dejó mi mentor Fernando Grosso, es que no existe diferencia entre la vida personal y el trabajo. Ese mito arraigado hace algunos siglos debería erradicarse. Corvalius plantea para nosotros el desafío de cumplir objetivos que tenemos a nivel personal. Y que muy lejos están del nivel de facturación o de la cantidad de empleados que la compañía pueda tener. Parte de la información que compartimos en nuestro CMS tiene que ver con una lista de sueños que esperamos poder cumplir a través de Corvalius (esto es real). Hacer cosas para Pixar o 3M, mejorar algún aspecto del cuidado de la salud, publicar un paper en Siggraph, ver la aurora boreal, escribir un libro o inventar la teletransportación. Tiene que ser personal. Parte de lo que tenemos que hacer en los próximos meses, es incluir paulatinamente esos sueños en los objetivos y diseñar planes para poder cumplirlos. Lo importante es estar involucrado fuértemente con el emprendimiento. Lo segundo es poder decirlo abiertamente

• Objetivos Claros y Foco: Nuestro plan fue conciso, nuestra propuesta a Huddle Group también. Trabajamos mucho para que las ganas sean objetivos posibles. Mucho esfuerzo y mucho quedó afuera. Fue importante poder descartar ideas difíciles de cuantificar u objetivos imposibles para poder tener claro los hitos que vamos a medir. Encontrar un área en dónde puede diferenciarse el grupo como conjunto y enfocarse en él. Lo importante del foco es que dentro de los objetivos que te estableces podes trabajar libremente, y cuando te salis de esos límites, te obliga a pensar qué estas haciendo.

• El futuro no llega. Se crea: Es importante ser concientes de esto. Para tomar al toro por las astas y ser partícipes de lo que está por venir. Todo el trabajo puesto en el plan fue invertido para crear futuro. Claro… para crear futuro y sus alternativas

Vamos a desarrollar muchos temas sobre los que hablamos en este artículo. Nos gustaría crear un ámbito en donde contarles las novedades de Corvalius fuera de los productos o los offerings que vayamos desarrollando. Después de todo, queremos ser transparentes y todo lo que ustedes no lleguen a ver, se los mostraremos nosotros.