When I built the C++ project, I noticed the fact that the actual DLL was not present in the project folder. I tried compiling under different configurations, but still – no result. The closest file (name-wise) contained dll.intermediate.manifest in its filename, but obviously that’s not what I was looking for.

I looked through the project properties and noticed this:

By default, the DLL was automatically deployed to the solution folder (obviously, in the current configuration subfolder), instead of the project folder. This might not be the best way to keep track of projects since when it is placed inside the solution folder, you are not able to keep track of the actual project that created it, especially if there are more than two projects in the solution.

To fix this, modify the Output Directory property to this:

$(SolutionDir)$(ProjectName)\$(Configuration)\

You will see the DLL being built in the correct folder now:

First, let’s look at the whole idea of cross-platform mobile development. There should be a single framework, accepted by hardware and software manufacturers on the market, that will control how code is executed and passed to the existing hardware. This means that there should be a strong third-parties – framework developer – hardware manufacturer relationship, the key player here being the framework developer.

For the mobile world in its current state, it is basically impossible to create a single set of tools to develop for every single platform out there. Mainly because of the strong software-to-hardware ties, but also because of the multitude of mobile devices and their hardware configurations. Of course there was J2ME – an attempt to make a mobile version of Java that would run everywhere. It required the devices to conform to a specific standard in order to support it, and as long as those minimum requirements are met, J2ME applications can successfully run on the device.

What J2ME architects failed to consider is the fact that hardware advances (and today it does this pretty fast), and not a lot of hardware manufacturers will stay behind simply because a software platform doesn’t support new functionality. J2ME didn’t advance fast enough – and developers wanted to use new hardware capabilities. What hardware makers do in this case? That’s right – look for another software platform. Eventually, today we can see that J2ME is dropped by the majority of smartphone developers due to its outdated nature and lack of capabilities to support new functionality.

That being said, here is a specific scenario. Let’s suppose there is a single framework that is supposed to let developers create applications that will run on a multitude of devices. If a hardware manufacturer decides to change its CPU architecture, for example, they will automatically fail to meet the requirements for that single framework. Even if the framework allowed compilation in a common intermediary language (like .NET and Java), there should be a conversion layer present, that will later on perform the intermediate-to-native compilation. So there are two choices:

• Keep the hardware outdated in order to support the software platform or wait till a conversion layer is released
• Update the hardware and develop a new software platform of their own

Chances are, the second option will be chosen. If that’s the case, the hardware manufacturer might hire a software development team and set the task to keep up with their hardware updates by developing updated software for new devices. Fair enough. Here we see the software-manufacturer dependability.

Now there also could be a different situation. The same agreement can be turned the other way around. A team of software developers (a very large team supported by a large corporation) creates a conceptual platform and signs an agreement with hardware manufacturers to create hardware for their software. As they update the software and add new functionality, the hardware manufacturers will release new versions of various hardware elements, like the CPU, higher resolution displays and/or better cameras. This is the case of Apple (iPhone), Google (Android) and Microsoft (Windows Phone 7).

In each of these cases, updates can be easily implemented without much hassle, since there is a one-to-one relationship between the software and hardware manufacturers and generally no software company depends on another one. From the other side, a single framework ties each hardware manufacturer to that set of libraries, each developer – to a limited set of libraries that expose a limited set of APIs. If a new device is released, providing better performance and new capabilities (for example, GPS support and an accelerometer) but the framework doesn’t support its full functionality, the device manufacturer has to wait until proper updates are released. In the meantime, someone else might release a similar device and then there will be loss of income and market share. If someone would decide to develop a better mobile OS for that matter, they would also have to wait till the framework is updated to support the new system. This is time-consuming and not a lot of major developers will allow themselves to wait.

Yet another important aspect is personal interest. Each company wants to be in control of the platform they are promoting. In case of a single development standard, if a company decides that there should be a change implemented in the framework, all other parties would have to agree with this. If someone doesn’t, that might create additional problems. If a company decides to switch their hardware and promote updated devices, they would have to force others to do the same and update the software layer. Once again, not everyone will be happy about that – what if someone doesn’t like the new device/software concept? While separated, though, each company is able to develop their own tools, with their own functionality set and capabilities.

A separation of platforms and development tools is beneficial – every participant is able to easily implement small changes and release the new product. At the same time, it makes it easier for developers to keep up with these changes, since they are focused on a specific platform only and don’t have to worry about general compatibility. I’m not saying that cross-platform development on mobile devices is impossible. It is, but it is nowhere near efficient.

However, if you are working on your application in Visual Studio, you can introduce the interface implementation in the class that inherits it a bit quicker. When you define that a class inherits a specific interface, a small blue rectangle will appear at the beginning of the interface name:

Point the mouse cursor to that rectangle and click on the icon that will appear:

UPDATE: As it was pointed by Curtis Rutland, you can actually open the list by pressing Ctrl + (+).

Select the Implement interface <Interface name> option:

Now the base ‘skeleton’ for the interface will be present inside the class:

It’s really hard to predict how this platform will turn out, though. Therefore, it is really hard to answer the question mentioned above. It was mentioned that the number of SDK downloads reached the mark of 300,000 – but does this really show what the development market for Windows Phone 7 will look like? Will we see at least 300,000 applications or it’s all about playing around with tools and doing something else after all? Same as the question that came before this, it is impossible to answer these at this very moment simply because the platform isn’t established as such yet.

Personally, I worked on developing some Windows Phone 7 applications, mostly for fun – I tried working on a RSS reader (you can see my adventures around that here and here), I tried working with push notifications and even created a small downloader tool. Of course, these are some very small projects, but I really liked working with some new tools and try new approaches. One thing that I am really concerned about is the difference between the emulator and the actual device. One of the most important things, in my opinion, when developing applications for a mobile device is having an emulator that will provide hooks to every single base function the device is able to perform, pretty much copying the entire device functionality. At this point, this doesn’t really apply to Windows Phone 7. A big gap in the current build of the emulator (this was probably actively discussed already) is the absence of accelerometer simulation. Of course, I do not expect to be able to tilt the emulator window (resource-wise, this would be pretty crazy), but I was thinking that I should at least be able to override the event parameters for the accelerometer to pass the needed location values. I do think that maybe in the RTM build there will be something for this and I will no longer have to use workarounds (like using the mouse only for X and Y coordinates).

I haven’t touched XNA development for the Windows Phone 7 yet, but I can say that there are a lot of possibilities that can be integrated in a Windows Phone 7 application. Pretty much everything you have access to in Silverlight is present in Silverlight for WP7 projects. Plus, device-specific functionality, like vibration capabilities and push notifications. As I mentioned before, if you have some background developing .NET applications, you are pretty much ready to start working on Windows Phone 7 apps, if you wish to of course. When I started, I encountered some issues (expected – the development tools are still in Beta) and it might take a little while to get used to the deployment and testing process, since it is highly dependent on allocated computing resources (hint: the emulator won’t pick up a XAP for testing if there is not enough free RAM) and is performed inside a hardware emulator.

I do hope that the platform will pick up some momentum, but the scarcity of devices to test apps on really plays its role right now – personally, I’d really like to test some apps on real hardware, but there is no chance to get a device (and yes, I know about some developers ‘renting’ devices – I’m too far a way from one) until it is released in public. By that time – I’ll just have to stick with the emulator. And this defines the extent of development I can do.

As a conclusions, I’d say that trying developing for Windows Phone 7 is a pretty interesting experience from a developer’s perspective, especially if you’ve never worked with mobile development before (just like me), since you will have to work in a limited ‘frame’ – the device the application will run on has limited capabilities and therefore you’ve got to make it use that potential to the max. Let the market potential aside, Windows Phone 7 seems like an interesting domain to work with since right now it’s one of those moments when developers witness the birth of a new platform and they will pretty much decide its growth and market share – we all know that today it’s all about the developers, developers, developers.

PS: Just out of curiosity, I am interested in finding out what do you think about getting involved in Windows Phone 7 application development. If you’ve got a minute, you can vote on my poll that asks this question.

When an application is deployed to the emulator, exit it (in case you were running), click on the application icon in the list of installed apps and hold the mouse button pressed:

Pinning the application will result in a tile being present on the Start page for your application (for easier access):

You can later on unpin the application. If you hold the left mouse button pressed on the application icon, there will be a crossed-out pin in the topmost right corner of the icon:

If you decide to uninstall the application, you will be prompted with a conformation message first:

If you uninstall it and later on want to resume the debug session, you will have to restart the emulator because Visual Studio 2010 will encounter a deployment error:

For example, I wanted to use some JSON parsing and RSS feed syndication tools, but by default, there were no System.Json and System.ServiceModel.Syndication libraries listed as available references.

So does that mean that you cannot use additional libraries that are available in standard Silverlight applications? Nope. All you have to do, is open the Browse tab in this dialog and navigate to one of these path (depending whether you are running on a 64-bit or a 32-bit system):

<SystemDrive>:\Program Files\Microsoft SDKs\Silverlight\v4.0\Libraries\Client

<SystemDrive>:\Program Files (x86)\Microsoft SDKs\Silverlight\v4.0\Libraries\Client

Some of the libraries that were missing are now available for you to use right out of that folder.

Here is a sample console application I came up with:

using System;
using System.Collections.Generic;
using System.Net;
using System.Threading;
using System.IO;
using System.Text.RegularExpressions;
using System.Drawing;

namespace ConsoleApplication
{
    class Program
    {
        static int totalFiles = 0;
        static int currentFiles = 0;

        static void Main(string[] args)
        {
            GetImages("<a href="http://www.textureking.com/index.php/category/all-textures%22);">http://www.textureking.com/index.php/category/all-textures");</a>
        }

        static void GetImages(string url)
        {
            string responseString;
            HttpWebRequest initialRequest = (HttpWebRequest)WebRequest.Create(url);
            using (HttpWebResponse initialResponse = (HttpWebResponse)initialRequest.GetResponse())
            {
                using (StreamReader reader = new StreamReader(initialResponse.GetResponseStream()))
                {
                    responseString = reader.ReadToEnd();
                }
            }

            List<string> imageset = new List<string>();
            Regex regex = new Regex(@"f=""[^""]*jpg|bmp|tif|gif|png",RegexOptions.IgnoreCase);
            foreach (Match m in regex.Matches(responseString))
            {
                if (!imageset.Contains(m.Value))
                    imageset.Add(m.Value);
            }

            for (int i = 0; i < imageset.Count; i++)
                imageset[i] = imageset[i].Remove(0, 3);

            totalFiles = imageset.Count;
            currentFiles = totalFiles;

            Console.WriteLine(totalFiles.ToString() + " images will be downloaded.");

            foreach (string f in imageset)
            {
                ThreadPool.QueueUserWorkItem(new WaitCallback(DownloadImage), f);
            }

            Console.Read();
        }

        static void DownloadImage(object path)
        {
            currentFiles--;
            Console.WriteLine("Downloading " + Path.GetFileName(path.ToString()) + "... (" + (totalFiles - currentFiles).ToString() + "/" + totalFiles + ")");
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(path.ToString());
            using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
            {
                Image image = Image.FromStream(response.GetResponseStream());
                image.Save(@"D:\Temporary\" + Path.GetFileName(path.ToString()));
            }
            Console.WriteLine(Path.GetFileName(path.ToString()) + " downloaded.");
        }
    }

}

The sample URL provided in the method call is used to download several textures linked on the webpage.

I am using regex to actually find the URLs. The case is ignored since I am not sure whether the file extensions are written with in caps or not. Since there is a chance for the same URL to be mentioned twice on the same page, I am making sure that there are no duplicates, so before adding the regex match to the List, I am checking if that already contains an entry for the match.

The final saving path also can be modified, but I decided to leave it hardcoded like this for testing purposes. In case you want to make the path dynamic, you can pass a generic collection or an array as the parameter for the DownloadImage method and then explicitly convert it and read the needed values (identified by an index, for example).

NOTE: I am using ThreadPool here so all threads are automatically set as background – if the application is closed, the download process will be canceled. To avoid this and wait for all downloads to complete (which is probably not a good idea but still a possibility), the Thread class should be used with IsBackground set to false.

There are two ways to achieve what you want.

Way A:

The most obvious thing would be creating a border around the control itself. Something like this:

<Border CornerRadius="5" BorderThickness="1" BorderBrush="Black" Margin="91,192,150,79">
<TextBox Background=”Transparent” BorderThickness="0" Height="35" Name="txtContents" Width="254" />
</Border>

That should do the initial trick – the TextBox control has no border around it (the BorderThickness property is set to 0) while the Border that contains it sets the correct rounding, color and thickness.

The rendered output will look like this:

Looking good, but the fun part comes around when you decide that this specific TextBox shouldn’t be enabled, so you set the IsEnabled property to False. What do you get? This:

What’s up with the rest of the white space between the border and the writing area? Doesn’t look like we want it to behave like this. And that’s where the second way to create rounded corners saves the day.

Way B:

It is a bit more complicated, but it gives a better result. What it does is it overrides the default control template for the TextBox. But how do I know how the default template looks like?

Since it is not possible to modify only one part of the template, the whole template should be overridden. To avoid functionality loss, I am going to get the default template and use it with small modifications.

To get the default style (that embeds the control template) for a TextBox control I am using the GetStyle method:

string GetStyle(Type t)
{
FrameworkElement element = (FrameworkElement)Activator.CreateInstance(t);
object styleName = element.GetValue(FrameworkElement.DefaultStyleKeyProperty);

Style style = Application.Current.TryFindResource(styleName) as Style;

StringWriter stringContainer = new StringWriter();
XmlTextWriter xmlWriter = new XmlTextWriter(stringContainer);
xmlWriter.Formatting = Formatting.Indented;

System.Windows.Markup.XamlWriter.Save(style, xmlWriter);

return stringContainer.ToString();
}

Since I am using the default control, without any custom styles attached, I can simply create an instance of TextBox and use its type as a parameter for the GetStyle method:

TextBox t = new TextBox();
Debug.Print(GetStyle(t.GetType()));

The output should look like this:

<Style TargetType="TextBox" xmlns="<a href="http://schemas.microsoft.com/winfx/2006/xaml/presentation&quot;">http://schemas.microsoft.com/winfx/2006/xaml/presentation"</a> xmlns:x="<a href="http://schemas.microsoft.com/winfx/2006/xaml&quot;">http://schemas.microsoft.com/winfx/2006/xaml"</a> xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:mwt="clr-namespace:Microsoft.Windows.Themes;assembly=PresentationFramework.Aero">
<Style.BasedOn>
<Style TargetType="TextBoxBase">
<Style.Resources>
<ResourceDictionary />
</Style.Resources>
<Setter Property="TextElement.Foreground">
<Setter.Value>
<DynamicResource ResourceKey="{x:Static SystemColors.ControlTextBrushKey}" />
</Setter.Value>
</Setter>
<Setter Property="Panel.Background">
<Setter.Value>
<DynamicResource ResourceKey="{x:Static SystemColors.WindowBrushKey}" />
</Setter.Value>
</Setter>
<Setter Property="Border.BorderBrush">
<Setter.Value>
<LinearGradientBrush StartPoint="0,0" EndPoint="0,20" MappingMode="Absolute">
<LinearGradientBrush.GradientStops>
<GradientStop Color="#FFABADB3" Offset="0.05" />
<GradientStop Color="#FFE2E3EA" Offset="0.07" />
<GradientStop Color="#FFE3E9EF" Offset="1" />
</LinearGradientBrush.GradientStops>
</LinearGradientBrush>
</Setter.Value>
</Setter>
<Setter Property="Border.BorderThickness">
<Setter.Value>
<Thickness>1,1,1,1</Thickness>
</Setter.Value>
</Setter>
<Setter Property="Control.Padding">
<Setter.Value>
<Thickness>1,1,1,1</Thickness>
</Setter.Value>
</Setter>
<Setter Property="UIElement.AllowDrop">
<Setter.Value>
<s:Boolean>True</s:Boolean>
</Setter.Value>
</Setter>
<Setter Property="FrameworkElement.FocusVisualStyle">
<Setter.Value>
<x:Null />
</Setter.Value>
</Setter>
<Setter Property="ScrollViewer.PanningMode">
<Setter.Value>
<x:Static Member="PanningMode.VerticalFirst" />
</Setter.Value>
</Setter>
<Setter Property="Stylus.IsFlicksEnabled">
<Setter.Value>
<s:Boolean>False</s:Boolean>
</Setter.Value>
</Setter>
<Setter Property="Control.Template">
<Setter.Value>
<ControlTemplate TargetType="TextBoxBase">
<mwt:ListBoxChrome Background="{TemplateBinding Panel.Background}" BorderBrush="{TemplateBinding Border.BorderBrush}" BorderThickness="{TemplateBinding Border.BorderThickness}" RenderMouseOver="{TemplateBinding UIElement.IsMouseOver}" RenderFocused="{TemplateBinding UIElement.IsKeyboardFocusWithin}" Name="Bd" SnapsToDevicePixels="True">
<ScrollViewer Name="PART_ContentHost" SnapsToDevicePixels="{TemplateBinding UIElement.SnapsToDevicePixels}" />
</mwt:ListBoxChrome>
<ControlTemplate.Triggers>
<Trigger Property="UIElement.IsEnabled">
<Setter Property="Panel.Background" TargetName="Bd">
<Setter.Value>
<DynamicResource ResourceKey="{x:Static SystemColors.ControlBrushKey}" />
</Setter.Value>
</Setter>
<Setter Property="TextElement.Foreground">
<Setter.Value>
<DynamicResource ResourceKey="{x:Static SystemColors.GrayTextBrushKey}" />
</Setter.Value>
</Setter>
<Trigger.Value>
<s:Boolean>False</s:Boolean>
</Trigger.Value>
</Trigger>
</ControlTemplate.Triggers>
</ControlTemplate>
</Setter.Value>
</Setter>
</Style>
</Style.BasedOn>
<Style.Resources>
<ResourceDictionary />
</Style.Resources>
</Style>

That is a lot of XAML markup right there, but all we need is the control template:

<ControlTemplate TargetType="TextBoxBase">
<mwt:ListBoxChrome Background="{TemplateBinding Panel.Background}" BorderBrush="{TemplateBinding Border.BorderBrush}" BorderThickness="{TemplateBinding Border.BorderThickness}" RenderMouseOver="{TemplateBinding UIElement.IsMouseOver}" RenderFocused="{TemplateBinding UIElement.IsKeyboardFocusWithin}" Name="Bd" SnapsToDevicePixels="True">
<ScrollViewer Name="PART_ContentHost" SnapsToDevicePixels="{TemplateBinding UIElement.SnapsToDevicePixels}" />
</mwt:ListBoxChrome>
<ControlTemplate.Triggers>
<Trigger Property="UIElement.IsEnabled">
<Setter Property="Panel.Background" TargetName="Bd">
<Setter.Value>
<DynamicResource ResourceKey="{x:Static SystemColors.ControlBrushKey}" />
</Setter.Value>
</Setter>
<Setter Property="TextElement.Foreground">
<Setter.Value>
<DynamicResource ResourceKey="{x:Static SystemColors.GrayTextBrushKey}" />
</Setter.Value>
</Setter>
<Trigger.Value>
<s:Boolean>False</s:Boolean>
</Trigger.Value>
</Trigger>
</ControlTemplate.Triggers>
</ControlTemplate>

Now, the ListBoxChrome wrapper should be removed and Border used instead, with the CornerRadius property assigned. The modified template looks like this:

<ControlTemplate TargetType="TextBoxBase" x:Key="txt">
<Border CornerRadius="5" BorderThickness="1" BorderBrush="Black" x:Name="Bd" Background="{TemplateBinding Panel.Background}">
<ScrollViewer Name="PART_ContentHost" SnapsToDevicePixels="{TemplateBinding UIElement.SnapsToDevicePixels}" />
</Border>
<ControlTemplate.Triggers>
<Trigger Property="UIElement.IsEnabled">
<Setter Property="Panel.Background" TargetName="Bd">
<Setter.Value>
<DynamicResource ResourceKey="{x:Static SystemColors.ControlBrushKey}" />
</Setter.Value>
</Setter>
<Setter Property="TextElement.Foreground">
<Setter.Value>
<DynamicResource ResourceKey="{x:Static SystemColors.GrayTextBrushKey}" />
</Setter.Value>
</Setter>
<Trigger.Value>
<s:Boolean>False</s:Boolean>
</Trigger.Value>
</Trigger>
</ControlTemplate.Triggers>
</ControlTemplate>

Additionaly, I added x:Key to the template header so I can identify it in my application. Now, this template can be inserted in the Resources section for a WPF application. Since I am testing this on a windowed WPF application, I will insert this template inside Windows.Resources.

The reference to the s namespace should be added as well (used for the IsEnabled trigger):

xmlns:s="clr-namespace:System;assembly=mscorlib"

Now I am able to reference the template for a TextBox inside the window:

<TextBox Template="{StaticResource txt}" Background="Transparent" BorderThickness="0" Height="35" Name="textBox1" Width="254" />

And now the rendered output looks like this:

Hey, but this one looks just like the one when I first tried using the border! True, but try disabling the TextBox now and see what it looks like now:

Just the way it should be. In case you do not need to change the look of the control when it is disabled, you can simply remove the IsEnabled trigger from the template so all you will have is this:

<ControlTemplate TargetType="TextBoxBase" x:Key="txt">
<Border CornerRadius="5" BorderThickness="1" BorderBrush="Black" x:Name="Bd" Background="{TemplateBinding Panel.Background}">
<ScrollViewer Name="PART_ContentHost" SnapsToDevicePixels="{TemplateBinding UIElement.SnapsToDevicePixels}" />
</Border>
</ControlTemplate>

It will correctly render the border, but there won’t be a grayed-out background and modified foreground when the control is explicitly set as inactive.

Therefore, starting with the next release of WeatherBar, the application will no longer be tied to a single weather service. By default, I will still ship the Google Weather plugin (it is already developed and ready for distribution), but there will also be alternative web services available.

To develop a plugin for WeatherBar, all that is needed is the WeatherBar Dev Kit. It can be downloaded here.

It includes:

• The SDK documentation
• Sample plugin (Google Weather API)
• WeatherBar Extension Test Tool 1.0 Beta

The WeatherBar Extension Test Tool can be used to test the plugin compatibility with WeatherBar 3.0. And although at this moment there is no official relase for the 3.0 build, this tool will ensure that the plugin works correctly and is able to expose the correct information.

I will be glad to bundle more extensions in the next release (for weather services other than Google Weather), so if you – the developer, created one, drop me a line. Once I make sure that your plugin works correctly and is using the correct format, I will be able to pack it in the final release. Of course, developers get the credit for their plugins.

After CouchDB hit its official 1.0 release, I decided to try it out and compare it to existing RDBMS, although this is probably not the right thing to do since CouchDB is based on a completely different paradigm. Anyway, I gave it a shot.

First of all, I decided that I will try it out inside a VM (Virtual Machine) and there are a few reasons for that. Back in the day, when having the opportunity to run a virtual machine on your computer was more of a privilege since resources were limited and the performance wasn’t even close compared to an actual install, doing something inside a guest system would at least earn you some weird looks – why run something inside a box when you can do the same on the host system?

But now times changed and virtual machines evolved. I can fine-tune the performance of my VM and considering the performance of the base machine (the actual hardware) I can simultaneously run two operating systems without seeing any significant performance loss for both of them (well, it still depends on what you are doing).

I use to experiment a lot with a wide variety of development tools and if I would install everything on my host system (Windows 7 Ultimate x64, if anyone interested). it will become cluttered in a matter of days and will practically be unusable. A VM provides a sandbox environment where I can do anything I want – in case something goes wrong, I can simply install a new VM instance and start from scratch. And of course, I am not risking my data on the base system.

The configuration for the VM I used is the following:

• CPU: 1 instance
• RAM: 512MB
• Video memory: 12MB
• Hard drive: 30GB
• Guest system: Ubuntu 10.04

My first thought was using Synaptic and install CouchDB from an existing official repository. But it wasn’t the case – there is CouchDB listed over there, but it was version 0.11.0 – I wanted to install 1.0.0. Therefore, there could be only one solution – compiling from source. Although this might seem a quite complicated process, in fact once you do it two or three times, you pretty much get used to the procedure and all you have to do is make sure the proper dependencies are present.

So I went ahead and downloaded the source for the 1.0.0 release. This can simply be done via the terminal (the wget command) but you can also use the web browser – depends on personal preferences. I followed the instructions on the official wiki page (Installing CouchDB on Ubuntu) and it all went smooth – dependencies installed, the main package is ready – until the point when ./configure threw me an error – it could not find the needed JS libraries. Since libmozjs-dev is clearly not available in Ubuntu 10.04, I was sure that I installed xulrunner-dev instead. But I did not specify this for ./configure, so I restarted the process, but already used the correct library references:

./configure –prefix= –with-js-lib=/usr/lib/xulrunner-devel-1.9.2.6/lib –with-js-include=/usr/lib/xulrunner-devel-1.9.2.6/include

It all went fine, but the story isn’t over yet. It was time to compile and install the server. Simple:

sudo make && make install

But not so fast – when it almost reached the ending stage, several errors were thrown notifying me that access to several locations was denied. Since I already used chmod and chown, I was a bit confused on what might be the issue. The solution was simple – I switched to my root account for the installation (and yes, I do know that this is not a good practice – but for the purpose of properly installing CouchDB it made sense). The command went through just fine and the CouchDB server was finally installed. I tried to start the service and the message that it was successfully launched was shown. However, when I tried to use curl to see the response, an error was thrown – it could not connect to the server.

The first thought that came to my mind in this situation was restarting the VM. But it didn’t help. Looking for possible solutions, I encountered this article. I tried running this command:

sudo –u couchdb couchdb

And indeed there was a problem – the user wasn’t able to access the main couchdb folder. I was thinking in the context of user permissions, but it didn’t really apply here, so I thought about folder permissions – I probably didn’t chmod something correctly. I tried doing it again by following the instructions but no positive results with that. And then I stumbled across another article that used the correct chmod values. Worked like a charm – I restarted the service ad was able to access the Futon web UI.

The installation wasn’t much of a “relax” at first, but the end result is worth it. Time for me to work more with it to see where I can use it and how.