Last Tuesday, we presented Mono Accessibility 2.1. We worked really hard on this release. Our main goals were, among other things, to improve our UI Automation Client API implementation, polish the interaction with at-spi2, better Moonlight accessibility and to handle custom and client-side providers. The great work made by all the contributors was the reason this release accomplished those goals.

What happened since last time?

Explaining this release is kind of hard if you are not involved in Mono Accessibility, and even more difficult if you’re not involved in Accessibility at all. However, if you’re familiar with Mono and .NET you are, also, aware of the possibility of developing .NET-based applications that run on both platforms with minor* changes or no changes at all. But, before the implementation of Mono Accessibility, there was something missing: all those applications were not accessible.

This meant two things. First Atk-based Assistive Technologies (ATs) were not able to access Windows Forms nor Silverlight applications. Second .NET-based ATs using UI Automation were not able to run on Mono. Making them useless for people requiring Accessibility to interact with software running Mono on Linux**.

After the implementation of Mono Accessibility, we have:

• UI Automation API Framework
• Bridge between UI Automation and ATK

This way ATs using either Accessibility Technology, Atk or UI Automation, will be able to interact with Gtk+, Windows Forms and Silverlight applications, with no changes at all.

This is what happened

In the following video: (if you are using a RSS reader click this link) gcalctool is launched and an application, using UI Automation Client API, interacts with it, clicking buttons “2″, “+”, “3″ and “=”.

Then UIA Explorer, a .NET- based application using UI Automation Client API, also interacts with gcalctool, if you pay attention you will notice that UIA Explorer also lists all other Gtk+ based applications, such as Nautilus and the GNOME Panel.

Finally Mozilla Firefox is executed (both Novell Moonlight with Accessibility Support and Novell Moonlight Accessibility Extensions plugins were installed prior running it) and an Atk-based Accessility Debugger, Accerciser, is launched to interact with the Moonlight application.

The source code used to test GCalctool is the following:

// gmcs -pkg:mono-uia gcalc.cs && mono gcalc.exe

using System;
using System.Linq;
using System.Windows.Automation;

namespace Mono.A11y.Examples {
	public class GCalc {
		public static void Main (string []args)
		{
			AndCondition cond
				= new AndCondition (new PropertyCondition (AutomationElementIdentifiers.ControlTypeProperty,
				                                            ControlType.Window),
				                    new PropertyCondition (AutomationElementIdentifiers.NameProperty, "Calculator"));
			var gcalc = AutomationElement.RootElement.FindFirst (TreeScope.Children, cond);

			cond = new AndCondition (new PropertyCondition (AutomationElementIdentifiers.ControlTypeProperty,
			                                                 ControlType.Button),
			                         new PropertyCondition (AutomationElementIdentifiers.NameProperty, "Add"));
			var addButton = gcalc.FindFirst (TreeScope.Descendants, cond);

			cond = new AndCondition (new PropertyCondition (AutomationElementIdentifiers.ControlTypeProperty,
			                                                 ControlType.Button),
			                         new PropertyCondition (AutomationElementIdentifiers.NameProperty, "Numeric 2"));
			var Button2 = gcalc.FindFirst (TreeScope.Descendants, cond);

			cond = new AndCondition (new PropertyCondition (AutomationElementIdentifiers.ControlTypeProperty,
			                                                 ControlType.Button),
			                         new PropertyCondition (AutomationElementIdentifiers.NameProperty, "Numeric 3"));
			var Button3 = gcalc.FindFirst (TreeScope.Descendants, cond);

			cond = new AndCondition (new PropertyCondition (AutomationElementIdentifiers.ControlTypeProperty,
			                                                 ControlType.Button),
			                         new PropertyCondition (AutomationElementIdentifiers.NameProperty, "Calculate result"));
			var calcButton = gcalc.FindFirst (TreeScope.Descendants, cond);

			cond = new AndCondition (new PropertyCondition (AutomationElementIdentifiers.ControlTypeProperty,
			                                                 ControlType.Button),
			                         new PropertyCondition (AutomationElementIdentifiers.NameProperty, "Calculate result"));
			var resultText = gcalc.FindFirst (TreeScope.Descendants, cond);

			// Clicking buttons
			InvokePattern addInvoke = (InvokePattern) addButton.GetCurrentPattern (InvokePattern.Pattern);
			InvokePattern Invoke2 = (InvokePattern) Button2.GetCurrentPattern (InvokePattern.Pattern);
			InvokePattern Invoke3 = (InvokePattern) Button3.GetCurrentPattern (InvokePattern.Pattern);
			InvokePattern calcInvoke = (InvokePattern) calcButton.GetCurrentPattern (InvokePattern.Pattern);

			System.Console.WriteLine ("Pressing \"2\"");
			System.Threading.Thread.Sleep (500);
			Invoke2.Invoke ();

			System.Console.WriteLine ("Pressing \"+\"");
			System.Threading.Thread.Sleep (500);
			addInvoke.Invoke ();

			System.Console.WriteLine ("Pressing \"3\"");
			System.Threading.Thread.Sleep (500);
			Invoke3.Invoke ();

			System.Console.WriteLine ("Pressing \"=\"");
			System.Threading.Thread.Sleep (500);
			calcInvoke.Invoke ();
		}
	}
}

Where do I get it?

If you installed Mono Accessibility 2.0 an option to upgrade should be available now, if not Mono Accessibility is available for a variety of Linux distributions, including:

• openSUSE 11.2 1-Click Install
• Ubuntu Karmic Koala Package Archive on Launchpad
• Fedora 12 openSUSE Build Service

Moonlight applications require the following extra steps:

• Install the updated xulrunner package from the above repositories. (Required until patch on bug #480317) gets approved.
• Install Novell Moonlight with Accessibility Support for 32 bit or 64 bit.
• Install Novell Moonlight Accessibility Extensions

Have fun and if you find any bug with this release, please file it. If you want to contribute or need specific assistance, please join our mailing list, or drop in #mono-a11y on irc.gimp.org.

* Of course this depends on what APIs you are using. If you want to know how compatible is your application try MoMA.
** Notice however, even though Mono is muti platform and UI Automation is included in both Mono and Silverlight, in order to allow other ATs running on other platforms, different than Linux, you will require to implement an specific bridge to talk to you OS Accessibility Layer.

Hackweek is an excellent opportunity to try something new. Hackweek V was not the exception. From June 7th to June 11th I joined a fantastic group of hackers to implement YaSTroid, our Android Front-end to WebYaST.

The week was fun. Learning new stuff, in this case Android, always helps me to see things different and somehow makes me appreciate other development platforms. Recalling Java was not that difficult. Honestly I thought Java had something new to offer to all developers, but it seems that Java hasn’t changed dramatically in years.

WebYaST and YaSTroid

WebYaST is an open source project which goal is to provide a web front-end for YaST functionality to enable remote 1:1 management. The interaction is basically like this (see the detailed diagram to get more information):

WebYaST and YaSTroid communicate using the REST API. If you have installed WebYaST you can access the documentation locally using:

http://localhost/restdoc

This website should show you a list of available methods and their arguments, if any, and examples showing you how to use them and the data returned. Pretty straightforward. Is also good idea to read the source code in case the documentation is missing. Everything is written in Ruby, so it should really simple to read.

Getting YaSTroid

Developing YaSTroid requires having Eclipse and Android installed. After that clone the repository. Make sure you are using Android 1.5 when defining your virtual device.

git clone git@gitorious.org:opensuse/yastroid.git

Result

Stephen and Scott recorded a video demoing the application using a real device, I recommend watching it full-screen to see all details:

If you can’t see the embedded video follow this link.

Usefull links

• YaSTroid by Stephen Shaw
• YaST – openSUSE

While reading The Ruby Programming Language I wrote a couple of notes about the language comparing it to C#. This is the first post of the series talking about those notes.

C# and Ruby share a similar syntax to compare equality in objects. Both use the operator equals (==) and, at least, one method to compare. Ruby uses equal? and eql?, C# uses Equals. Also, both support overriding the equals (==) operator to provide a different logic in case that’s required. The methods’ name are different but they work pretty much the same.

Understanding the difference between both languages is really simple. If you already know the difference between reference types and values types you are pretty much all set.

Ruby

Method equal?

Method used to test reference equality in two objects. For example:

#!/usr/bin/env ruby

a = 0
b = 0.0
c = b
d = e = 0

# "false" pointer c points to b, and b and a
# are different types.w
puts "c.equal?(a) #{c.equal?(a)}"
# "false" b and a are different types
puts "b.equal?(a) #{b.equal?(a)}"
# "true" Same type, same value.
puts "d.equal?(e) #{d.equal?(e)}"

Method eql?

Synonym of equal?, not strict type conversion. Notice Hash classes uses this method for creating the hash, so if two values are the same the hash method should return the same value.

#!/usr/bin/env ruby

a = 0
b = 0.0
c = b
d = e = 0

# "false" Pointer c points to b, and b and a are different types
puts "c.eql?(a) #{c.eql?(a)}"
# "false" Different types
puts "b.eql?(a) #{b.eql?(a)}"
# "true" Same type, same value.
puts "d.eql?(e) #{d.eql?(e)}"

Operator equals (==)

By default, in Object class, it’s a synonym of equal?. Tests reference equality.

#!/usr/bin/env ruby

a = 0
b = 0.0
c = b
d = e = 0

# "true" Even when pointer c points to b, and b and a
# are different types, the value is the same
puts "c == a #{c == a}"
# "true" Type is casted to allow comparing them
puts "b == a #{b == a}"
# "true" Same type, same value.
puts "d == e #{d == e}"

C#

Before explaining the equality options, notice one important difference between Ruby and C#.

First, Ruby is a dynamic typed language. When declaring variables there’s no meaning of variable type, all variables can be used to identify instances of different types depending on the situation. For example, we can define a variable x to act as a string, and then use the same variable x to act as an integer, this doesn’t mean we are converting the string to integer, this means we are using the same pointer (variable x) for two different types, string and integer, pointing to two different addresses in memory. For example:

#!/usr/bin/env ruby

a = "I'm string"
# Output: "a Value: 'I'm string' Class: 'String'"
puts "a Value: '#{a}' Class: '#{a.class}'"

# Output: "a Value: '10.0' Class: 'Float'"
a = 10.0
puts "a Value: '#{a}' Class: '#{a.class}'"

C# is a static typed language, all variables must indicate their type before instantiating an object. For example, when declaring a variable x of type string, you will be able to create an instance of string, only, there’s no way to “reuse” x as an integer in the same scope. Try to compile the following example, it will fail:

public class RubyAndCSharp {

	public static void Main (string []args) {
		string x = "I'm string";
		System.Console.WriteLine ("a Value: '{0}' Class: '{1}'", x, x.GetType ());

		x = 10.0; // It will fail here: "error CS0029: Cannot implicitly convert type `double' to `string'"
		System.Console.WriteLine ("a Value: '{0}' Class: '{1}'", x, x.GetType ());
	}
}

Second, memory management. Both languages manage memory automatically: by default all memory is created and released automatically, there is no need to explicitly release or allocate memory, unless the programmer wants to do so. However, in C# there’s a “difference” between types. There are two type categories: Value Type and Reference Type. The difference, related to memory use, is the way they work and the addresses in memory they use. Declaring value types automatically allocates memory, declaring reference types declares a pointer and the memory is allocated when the object pointed by the variable is instantiated. The Value Types are allocated in the stack and the Reference Types are allocated in the heap.

This difference is really important. Comparing two instances of objects with different “category”, one value type and one reference type, does not work, it just fails. Is like comparing an apple to an orange. Is comparing a value stored in the stack to a value stored in the heap. We can’t compare them without writing any extra code.

And this extra code means using the base class object as the pointer for different types, because both types, value type and reference type, are subclasses of object, in one way or another. Let’s try to compile the following example:

public class RubyAndCSharp {

	public static void Main (string []args) {
		object x = "I'm string";
		// Output: "a Value: 'I'm string' Class: 'System.String'"
		System.Console.WriteLine ("a Value: '{0}' Class: '{1}'", x, x.GetType ());

		x = 10.0;
		// Output: "a Value: '10' Class: 'System.Double'"
		System.Console.WriteLine ("a Value: '{0}' Class: '{1}'", x, x.GetType ());
	}
}

After this short (or long?) explanation we are ready to see talk about the methods.

Method Object.Equals()

Is used to test reference equality in reference types and bitwise equality in value types. For example:

public class RubyAndCSharp {

	class MyClass {
		public string Name { get; set; }
		public override string ToString () { return Name; }
	}

	public static void Main (string []args) {
		// object.Equals in Reference Types uses address memory
		MyClass myClass0 = new MyClass () { Name = "test" };
		MyClass myClass1 = myClass0;

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myClass0, myClass1, object.Equals (myClass0, myClass1));

		// Let's try again. This will return false. myClass1 and myClass2 are different instances
		myClass1 = new MyClass () { Name = "test" };

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myClass0, myClass1, object.Equals (myClass0, myClass1));

		// It doesn't matter myInt0 and myInt1 are different variables, equality will be true.
		int myInt0 = 1;
		int myInt1 = 1;

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myInt0, myInt1, object.Equals (myInt0, myInt1));
	}
}

Operator equals (==)

Is, basically, a synonym of object.Equals, same rules apply.

public class RubyAndCSharp {

	class MyClass {
		public string Name { get; set; }
		public override string ToString () { return Name; }
	}

	public static void Main (string []args) {
		// == in Reference Types uses address memory
		MyClass myClass0 = new MyClass () { Name = "test" };
		MyClass myClass1 = myClass0;

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myClass0, myClass1, myClass0 == myClass1);

		// Let's try again. This will return false. myClass1 and myClass2 are different instances
		myClass1 = new MyClass () { Name = "test" };

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myClass0, myClass1, myClass0 == myClass1);

		// It doesn't matter myInt0 and myInt1 are different variables
		int myInt0 = 1;
		int myInt1 = 1;

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myInt0, myInt1, myInt0 == myInt1);
	}
}

Operator Object.ReferenceEquals()

Pretty straightforward, tests reference:

public class RubyAndCSharp {

	class MyClass {
		public string Name { get; set; }
		public override string ToString () { return Name; }
	}

	public static void Main (string []args) {
		// Object.ReferenceEquals in Reference Types uses address memory
		MyClass myClass0 = new MyClass () { Name = "test" };
		MyClass myClass1 = myClass0;

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myClass0, myClass1, System.Object.ReferenceEquals (myClass0, myClass1));

		// Let's try again. This will return false. myClass1 and myClass2 are different instances
		myClass1 = new MyClass () { Name = "test" };

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myClass0, myClass1, System.Object.ReferenceEquals (myClass0, myClass1));

		// This will also return false.
		int myInt0 = 1;
		int myInt1 = 1;

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myInt0, myInt1, System.Object.ReferenceEquals (myInt0, myInt1));
	}
}

Colophon

Sometimes you will have to use an object reference to refer to both types, value and reference, if you are planning to compare their value you have to use the static method object.Equals(a,b). Using the operator equals (==) will always return false, because of the boxing/unboxing:

public class RubyAndCSharp {

	public static void Main (string []args) {
		string str0 = "hola";
		string str1 = "hola";

		object obj0 = str0;
		object obj1 = str1;

		System.Console.WriteLine ("Equals: {0}, Using ==: {1}, object.Equals {2}",
		                          obj0.Equals (obj1), // True
		                          obj0 == obj1, // True
		                          object.Equals (obj0, obj1)); // True

		bool bool0 = true;
		bool bool1 = true;

		obj0 = bool0;
		obj1 = bool1;

		System.Console.WriteLine ("Equals: {0}, ==: {1}, object.Equals {2}",
		                          obj0.Equals (obj1), // True
		                          obj0 == obj1, // False
		                          object.Equals (obj0, obj1)); // True

	}
}

Updated 2010-03-17: Thanks to sukru for noticing the error in the examples.

Updated 2010-03-18: Fixed typos, thanks to yoeri and doza noticing them.

Yes! Your favorite task management application is back. Tasque v0.1.9 was released today!. New features include:

• Support for Mono >= 2.6
• Customizable color highlighting in tasks.
• Hiveminder improvements
• New translations
• And more!

See the announce email to get more information.

Get it while it’s hot!

Screenshots?

More here!

Where to get?

• Main Downloads page
• Sources
• Mac OS X binaries
• MS Windows binaries

More information?

• Wiki
• FAQs

By Claire L. Evans / CC BY-ND 2.0

This is an updated version of Multiple Parallel Mono Environments.

What is Pulque?

Pulque is a collection of applications written in Ruby and Bash scripting to maintain parallel development environments.

Why does Pulque exist?

Three reasons:

1. I need to keep multiple versions installed of the same software,
2. I need to know what Version Control System is used by the software, and the most important
3. I want to keep myself sane.

At work, I have to interact with different open source projects, most of them use Subversion and Git, but some others use Bazaar and Mercurial. Keeping track of the current parallel development environment and the VCS used by the software is exhausting.

You spend time focusing on something that shouldn’t be that important:

• Managing your parallel environments and,
• Keeping track of the VCS used by the software

Is easy to get confused when interacting with the repository, for example, executing svn update when the software is stored in a git repository. Is silly, but it happens. Unless you are using an IDE that support Multiple Parallel Development Environments you will need the terminal to configure and build your projects.

Pulque helps you maintaining parallel development environments by:

• Printing in the bash prompt the name of the parallel development environment and the type of the VCS, this information is updated depending on the working directory,
• Defining aliases to the default commands used to configure and build the software project, to always prefix your projects using your parallel environment, and
• Showing a failure or success alert when the command finishes.

Installing and using Pulque

Follow the instructions in INSTALL, or if you are using openSUSE 11.2:

Click here to drink Pulque!

Don’t forget to add the function pswitch to your .bashrc. Bash will autocomplete your environment name when using TAB TAB.

function pswitch {
  source /usr/bin/__pswitch $1
}

Read the USING file to understand how to use Pulque in the daily basis. If you find something weird or interesting please create an issue to fix it.

Colophon

According to Wikipedia: “Pulque, or octli, is a milk-colored, somewhat viscous alcoholic beverage made from the fermented sap of the maguey plant, and is a traditional native beverage of Mexico.“

A couple of days ago I finished reading: The Ruby Programming Language, book written by David Flanagan and Yukihiro Matsumoto. If I have to say anything about the book and, the language, of course, is: I am impressed. The syntax is pretty for writing and simple for reading. Its simplicity makes you understand the code, is like visualizing the goal of the program in your mind by reading it, not running it. It is like reading a well written letter. You just understand.

I must say, when I was reading the book, at the beginning. I did not feel comfortable with the weird, at that time, syntax. Method decorations such as “!” and “?”, and the support for methods aliases made no sense. Actually I thought I was wasting my time by trying to learn the language. I was wrong.

When I learned C++ several years ago, I did not have reference to object orientation or any object-oriented programming language. Learning it was difficult, but, at the same time, easy. Difficult because I did not know the paradigm, easy because it was my first time learning that kind of syntax. After learning C++ I decided to learn Java and after that, I decided to learn C#.

And I learned them all the same way. I “translated” the syntax. Translated it from the “new language” to the “old language”. I did learn them all. And I thought, for long time, that the rule was: “Learn all the languages the same way: by translation”. I was wrong. Again.

Learning a new programming language, in my opinion, is better when you do not translate the new language. Similar to learn to speak a new language. In both cases, you have to think in the language. I decided to think in the new language. To do it that way. The Ruby way. The results were amazing. Were so amazing that inspired me to write a project in Ruby. I wanted to try out the syntax, the platform and the community. To see if the language was that good as I thought.

After trying it out. No disappointments at all. Actually is interesting that C# and Ruby share a lot of things, syntactically speaking. Both of them are pretty languages. Probably they do not share goals. However, I’m sure they share one goal: to make the life of the software developer easier. And, to a software developer, a programming language, and everything around it, that makes your life easier is what matters the most.