Selling custom build applications on a license base is also in line with the movements that are going on the software market in general. With the introduction of cloud computing and SaaS, on which software applications more and more rely, many more software companies are moving to licensed base selling models. But to be able to sell custom build software at license base, you should be able to minimize the costs on the custom development part.

For my home automation framework, the only parts left for custom development will be the configuration of modules, the user interface and vendor specific protocols. With the current version of my framework, it will take around two days to implement all supported functionality for the average http based protocol. The framework will take care of queuing, error handling etc., so these techniques do not have to be implemented for each protocol separately taking also away a lot of work.

As most of the efforts will be on the shared part, it might be possible to share these costs over the licenses. A margin will cover in most cases the custom development part. Only clients who like to have complex protocols to be implemented have to take additional custom development fees in account.

One of the most important characteristics of the framework is that it’s basic design should be applicable to a broad range of devices, from smart phones to home automation gateways. This is a really big challenge, as all these kind of devices have to deal with different kind of requirements like power consumption, usage of resources and costs on data usage. However, we see, for example with looking at the upcoming Windows 8, that even complete operating systems are now being designed in a way that they can deal with all these kind of requirements.

I will not describe the framework in every detail, but some of the most distinguishing features will be discussed in this blog post. I will begin with the way the framework will handle data.

Home automation systems are build up by multiple devices like lights, climate sensors, multimedia equipment and much more. There could also be involved multiple devices that are meant as interfaces between these devices, like network bridges and serial device servers. The framework will be capable of collecting information from all these systems. Extensions can be made easy on top of basic functionality like error handling, queuing and auto detection mechanisms.

All information collected from the devices, including rooms, scenes etc. that have been configured, will be stored into a cash. Rooms, scenes and other duplicate information will be merged automatically. This collection of data will form a layer between the connections with the home automation systems and the applications on top of it and can be extended with data objects for all kind of devices.

Depending on the type of device, a user interface or other application will be build on top of the data cash. The user interface will also be build using specif patterns making it possible to define it’s design without knowledge about the protocols or any other technical implementation on device level. Applications, like speech recognition, macro engines etc. can also be build on top of the same interfaces, making them usable at multiple home automation systems.

Next to these three layers, other extensions can be made in the form of managers. A manager will be responsible for one specific functionality like data storage, connection management or user interface themes. A connection manager for example will, in case of a smart phone, be responsible for making the choice to connect using a local connection or via Internet. The base for this manager will be the same for all smart phone applications, but implementation will be different as each smart phone OS will have it’s own set of APIs to determine when the devices uses for example a cellular data connection.

The image below gives an abstract view of how all components are related to each other.

I believe that this kind of frameworks will be integrated in all kind of operating systems like Windows and Android. Google is already active on home automation with it’s Android@Home project and the nice video’s in which Microsoft show their vision about the future also make us believe that integration of all devices in home will become a fact.

Integration of home automation frameworks into operating systems will bring home automation to a next level where integration with for example smart grid systems will be realized via apps that can be downloaded and run distributed over multiple devices.

It should be a year of 7 or 8 ago when I came up with the idea of a framework that should make it possible to synchronize object models between software applications running at different devices. While frameworks for synchronizing objects where also at that time not something new, my ideas went a little bit further by making it possible to define different kinds of behaviour like permissions at higher abstraction levels, load data via XML like documents and a self organizing network of connected nodes. However, also some other things got my attention like domain specific modeling and those ideas disappeared to the background.

When I started the development of software for controlling home automation systems, my ideas of synchronizing objects got a second life. What I wanted to create was software that collected all information from home automation devices in home and handles that information in a uniform way, making it easy to build user interfaces and other application on top of it. The design that resulted from there made it into a smart phone application I call eControl.

Many home automation systems work with a central device or server (also called Home Automation Gateway). All home automation devices in home will become registered on this central unit and smart clients will control them through this central unit. The central unit will function as a kind of translation device. To be able to controll devices from the Internet, the central unit will connect to a kind of forwarding service on Internet. The image below gives an impression of such a set-up.

Home Automation System Centralized

eControl however is designed in a way that it will be less depending on a central unit. Where possible, eControl will connect directly to devices in a self organizing way, making setup of a home automation system much easier. eControl will also make optimal use of services available with the smart phone, like cloud storage. In many cases, this will even take away the need for the end user to set up additional user accounts. The image below shows the same set-up with eControl.

Home Automation System with eControl

Of course, to profit from all these advantages, the home automation systems to connect with should also support discovery mechanisms and automatic port forwarding. Also some additional security precautions have to be taken and multiple data connection can have advantages but also disadvantages around data efficiency.

The architecture of eControl is also suitable to be used in other kinds of home automation software. A framework is already under development and will form the base of eControl. For the moment, only elements that are crucial for making eControl a functional application are implemented.

My projects can be compared with a multistage rocket. To bring one project on a higher stage, it needs anther project to lift on. My home automation projects are projects that are needed to bring other projects of myself to a level they can be launched. From the first stage off launch, untill the last launch, the rocket will look like:

• Smart phone application for controlling home automation equipment
• Home automation framework
• Offering custom build home automation software at license base
• Automated software product line for home automation software
• Platform for creating automated software product lines
• Platform for automated software creation by using knowledge from expertise systems
• Automated software creation using AI algorithms

Each stage will result in it’s own products that are part of a much more ambitious vision. Unlike a multistage rocket I hope that jettisoned stages will grow further in a way that they will profit from the results of following stages instead of burning into the atmosphere. However, they are primarily meant to serve a higher purpose. For example the smart phone application will be build in a way that it can grow with the framework. Thereby, the smart phone application will influence the design of the framework. The framework will be designed in a way that it extensions can be made at minimal efforts, making costs more predictable and making it possible to offer custom build software at licence base. And this way it will go further.

The ultimate goal will be a situation in which programs (simple as well as complex) will be created from scratch without the involvement of software developers. This sounds like science fiction, but I really believe it will be possible. Of course it will take us many years to get there, but it will provide us with enough challenges for the next decades.

I will write a blog post about each of the stages. By doing this, I hope to get in touch with people who share my vision and also see opportunities.

The Arduino uses a ATmega328 which is a 8bit microcontroller with only 32KB of flash memory and running at a max of 16MHz. The ethernet shield is using a simple W5100 controller, which means that all TCP/IP protocol handling should be done by the micrcontroller. So I’m not cheating by using an ethernet controller with build in webserver.

To compare, the average home router (sold around 25 Euro) contains a 32bit microprocessor running over 100MHz and contains at least megabytes of flash. The average smart phone (sold around 200 Euro) comes is around1GHz containing gigabytes of Flash. For the people not knowing what I’m talking about, it will be hard to find cheaper hardware then the hardware I used for this prototype.

The prototype includes the following functionalities:

• Automatically obtaining an ip-adress from an home router using DHCP
• Advertising the device (making it detectable) using a online service connected to using DNS
• Simple HTTP server making it possible to smartphones, computers etc. to connect
• HSV like color cycling

And there is even enough memory left for applications like:

• The addition of an RF Transmitter making it possible to control for example wireless wall switches
• Running time schedules, scenes etc.
• Addition of climate sensors
• Addition of an IR-receiver

A YouTube movie will be created soon!

My good intention for this year is to share more about my activities on code generation, home automation and mobile development. I would like to invite you all to follow me on Twitter @a_savelkoul and @ExtundoApps.

Within the next year, a number of applications for smart phones and tablets will be developed and released. Many of my ideas that are now just concepts will find their way to the world through these applications.

In contrast to the previous year, there were a lot of companies showing home automation interfaces on SmartPhones and Tablets. Together with developments like Philips leaving this market with its Pronto remotes, we can conclude that the market is moving rapidly and new market segments will get in reach. However, one of the most important things to make tablets a really interesting replacement for dedicated remotes is to improve the user interfaces. I am sorry that I have to say it, but in general they are still awful!!! Companies are often still trying to push as much as possible on a single screen or are nearly literally copying the user interfaces of there competitors because they seem to miss the initiative to do some research themselves.

There was also a lot of attention for Smart Metering. Not only companies specialized in Smart Metering could been found on the event, but also a lot of general purpose home automation systems were showing energy statistics on there touch panels, web interfaces and whatever you can think about.

The lower-end market was, just like previous year, underrepresented. There was only one company that really got my attention after speaking with them. This start-up will enter the market March next year with surprisingly low priced home automation sets. For a little bit more than 200 Euro for a starter set containing a small remote with display, internet gateway, two switches, two dimmers and two energy meters it will be still difficult to attract people who are still thinking about spending a tenner for a wireless remote set from the DIY-shop. But I am sure it will attract people that realize that a Z-Wave set is much more value for money than a set from the DIY-shop. Other people need something more.

At the end of the day I can conclude that there are a lot of opportunities for my own plans for home automation. I am nevertheless still missing something that will make home automation really attractive for the mass public. Looking at the popularity of the overpriced iPad, I am sure that this will no longer be the price. The fun-factor has become the main focus of the public and needs therefore to be taken into consideration.

However, from the usability perspective I still see room for improvements. MetaEdit+ is definitely one of the more intuitive and flexible domain modeling tools. Nevertheless, the user still has to get used to concepts as languages, visualizations and models. From a technical perspective I really prefer this clear distinguish, but for domain experts who would like to create models without being forced to use a language pre-defined by others it might be interesting to make this as transparent as possible. 

After seeing and working with tools like the Microsoft DSL Tools, Microsoft SQL Modeling, MetaCase MetaEdit+, MetaEnvironment (CWI) and Intentional Software, the conclusion is that they all have some overlap in concepts, but are unique in their own way. Some tools are more focused on academic people with knowledge about formal languages, others on developers creating frameworks. But in all the tools I am missing something and that is the focus on domain experts and collaboration between people with different kind of expertise. 

For the most part language workbenches seem to follow a process, where as the first step a language has to be designed, then a visual representation and then the models. Before a domain expert is able to define its models someone with knowledge of designing languages should be involved. In some cases, languages and visual representations even have to be compiled and distributed by installation packages before they can be used. This might be no issue when these tools are used in combination with existing software frameworks. A very good example of a successful DSL is the ACA.NET Service Factory from Avanade, build using the DSL Tools from Microsoft. ACA.NET Service Factory is build for a technical domain, meant to be used by developers and to be used at multiple projects to pay back the investment. The DSLs in this case are quite stable, so not using dynamic modeling tools is not a big issue. 

The less flexible a DSL tooling will be, the more time it will take to develop a specific version of a DSL. In my opinion, this will become an issue on projects where custom build DSLs are a key element of the requirements engineering and development process and constantly subject of changes. But how can we make DSM more interesting for to be used in crucial parts of projects where the domain is not clear yet?
In practice, domain experts within companies already created their own languages. They use applications like Excel to write down business roles. One example I have are the medical acceptance procedure from my Masters thesis. The medical advisor used Excell sheets. These sheets had columns to refer to other questions depending on the answers given and columns with values for calculating risks. The sheets however could not be used as input for generating code. 

I am working on a concept that will follow different process of designing languages then currently used when working with other language workbenches. In my concept models are used as a starting point rather than a language design. The first prototype I am creating will definitely support tables, graphs and forms but might also include for example flows and trees in future versions. The first step by the user will be to choose a visualization form it thinks will be suitable to express its thoughts, for example a table. The user then puts the data into the table. When it adds columns, it is has to name them. By doing this, the user is creating a language.
The previous months I have worked on a prototype. The results so far are, despite of a lot of concessions I had to made, very promising. Building a graph tool using WPF (Windows Presentation Foundation) is one of the biggest challenges I am currently focusing on, but will result in a interactive experience for the end user. In the coming months I intend to post about my experiences with WPF and post more details about the design of my prototype.