I’m happy to announce that ExpressionFlow has today evolved into a LabVIEW and visual object-oriented programming blog community as Anthony Lukindo becomes an ExpressionFlow author. The authors at ExpressionFlow are enthusiastic software developers and exceptional LabVIEW professionals and Anthony makes no exception. Anthony Lukindo is an owner of an NI Alliance Member Company, Mezintel Inc., located in Calgary. Anthony has received his Ph.D. in BioSystems Engineering and has strong experience in LabVIEW development. Anthony’s special expertise is on LabVIEW database interfacing on which Anthony is going to write his first ExpressionFlow articles. I’d very much like to welcome Anthony Lukindo as an ExpressionFlow author.

To better match the new community status of ExpressionFlow I’ve made some changes to the site content and look-and-feel. If you encounter any problems, don’t hesitate to inform me.

When I put up ExpressionFlow less than three months ago I didn’t expect high traffic rates right from the beginning. However, to my surprise there has been over 10000 pageviews during the last three months. That exceeds all my expectations. I’d like to thank everyone for supporting this site. If you already haven’t done so subscribe the feed. We are going to have a lot of interesting stuff coming up!

Yesterday the OpenG Class Template Framework together with a few OpenG class templates were released. I now try to explain shortly what these templates actually are and how do they function.

OpenG Class Templates are nearly normal LabVIEW classes that are stored under resource\OpenG\openg_object\class_templates folder under LabVIEW installation directory. To be used OpenG Class Templates require a separate tool that can create new classes from the templates and that can manipulate existing classes created from class templates.

The class file of LabVIEW classes is always an XML file with information of class properties, class private data and class item properties. OpenG Class Templates differ from regular LabVIEW classes in that additional information is added to the lvclass XML file of the templates. This additional information explains the template tool such as Endevo GOOP Development Suite how to work with the templates. Based on this additional information the template tool knows how to create new classed based on the templates, how to create new methods from method templates, how to rename class based on a template and how to update template changes to template based classes.

When user wants to create a new class that is based on a OpenG class template, he needs to do this via a tool that support OpenG class templates. In the process, the tool creates a copy of the template and manipulates the copy according to the template meta data written in the template XML file. The tool also adds additional attributes to the class file created from the template so that this class can be recongnized to be based on a tempalte and the template used can be located. When there are changes in the template, these changes can be applied to the classes based on the template using this metadata in the class files.

As the templates are more or less regular LabVIEW classes, they can also depdend on other templates in a very similar manner as LabVIEW classes inherit from parent classes. For example OpenG Active Object Template is based on OpenG Reference Object Template. Active object is actually a referece object with some extra features and with a few changes in some underlying mechanisms. The inter-template dependency means that changes to parent templates can propagate via the child templates to classes created from the templates. This of course requires support from the tool being used.

The tools that support OpenG Class Template specification should be able to recognize any template in the above mentioned template directory. This makes it possible for the developers to create their own class templates specific to their own needs. However OpenG Class Template specifications are quite complex yet capable and it is not very easy to create new class templates. The complexity of the template mechanism also means that it’s probable that in the beginning only tested templates will work with tools supporting OpenG Class Templates and actually the support for custom templates will see light only when the tools get more mature.

For the past few months I’ve been working on a very interesting project together with Endevo from Sweden with Jim Kring from JKI. I have had the opportunity to design open source OpenG Class Templates for LabVIEW Object-Oriented Programming. Endevo has developed a GOOP Development Suite that allows developers to create classes from these OpenG templates directly from LabVIEW user interface. OpenG templates together with Endevo GOOP Development Suite has the potential to fundamentally change the LabVIEW object-oriented development process.

OpenG Class Templates

When LabVIEW Object-Oriented Programming was released about a year ago, I had a lot of expectations. Unluckily the features of LabVIEW OOP didn’t meet with my development needs. I needed by-reference classes to be able to represent complex data structures and encapsulate storage interface to classes. I needed user definable constructor and destructor for my classes to guarantee initialization and clean-up. With these needs I started to think of the ways how I could best implement these features on top of native LabVIEW OOP.

The aim of the OpenG Class Templates is to overcome the above mentioned shortcomings of native LabVIEW object-oriented programming by including features lacking from native LabVIEW OOP to OpenG class templates. Two most interesting OpenG templates are without doubt a queue based by-reference class template and a class template for active asynchronous objects.

Queue based by-reference class template allows developers to create by-reference classes with user defined object construction and destruction steps and with asyncrhonous parallel data access and data locking. By-reference classes are the proper choice when one needs to create objects with indentity and lifetime. Numerous use cases include encapsulation of instrument drivers, file handling, database access, network interface and urser interface components.

Template for active asynchronous objects combine by-reference objects with a thread of their own. Each object includes a parallely executed VI that is started during object construction and closed when object is closed. This parallely executed VI can receive and reply-to asyncrhonous messages from other parts of the program. Active objects can be considered to provide an active state-machine based service that other parts of the program or external components can communicate with using the object methods.

OpenG class templates are based on OpenG class template specifications. These specifications define a standard which allows all developers to create new class templates either from scratch or based on existing class templates. Furthermore developers can use these templates with any LabVIEW tool that confroms with the template specifications. Currently the only tool available is Endevo GOOP Development Suite.

OpenG wiki provides instructions on how to get and install OpenG class templates.

Endevo GOOP Development Suite

Endevo GOOP Development Suite (GDS) has an opportunity to revolutionize LabVIEW object-oriented programming based development. Being integrated directly to LabVIEW project environment Endevo GDS makes it very easy and fast to work both with native LabVIEW classes and with template based LabVIEW classes. The speed-up of the development process is actually enormous when the development suite takes automatically care of things like creating method icons etc.

Endevo GOOP Development Suite supports three kinds of classes; native LabVIEW classes, classes based on OpenG templates and classes based on Endevo templates. All of these alternatives are based on native LabVIEW object-oriented programming. Actually Endevo GDS allows users to create and add their own class templates that meet OpenG class template specifications.

GOOP Development Suite comes in two editions, limited functionality free Community Edition and in Professional Edition. Both versions of GOOP Development Suite can be downloaded directly from Endevo web site.

Conclusions

OpenG Class Templates together with Endevo GOOP Development Suite have a lot of potential to change the way LabVIEW object-oriented programming is beign used. I’ll keep blogging on the usage the templates. Subscribe to the feed not to miss any of these future articles.

Visual programming is gaining more and more visibility outside the the LabVIEW community. In ITWritings blog Tim Anderson draw attention to the fact that multiple visual programming languages have gained public attention lately. These include a visual programming environment Scratch for kids by MIT, Yahoo pipes RSS feed syndication language and Microsoft PopFly online visual programming language for Silverlight.

It seems that visual programming languages are gaining attention in the field of domain specific languages. This is definitely the right route to go as the main stream general purpose programming languages are hard to replace. In addition domain specific languages allow gathering experience on visual programming in general that can later be leveraged on more general purpose language domains.

National Instruments (NI) has been very protective in the field of visual programming. NI owns multiple visual programming related patents and has used this patent portfolio to keep other companies out of the field of visual programming. It’s interesting to see if NI will continue it’s protective policy and sue MIT, Yahoo and Microsoft for patent infringements.

User interface may be the one most important part of your LabVIEW application. It’s the only part of the application the end-user is directly in contact with. Still user interface is often the part of a LabVIEW application developers spend the least time with in the development process. Does LabVIEW make creating decent user interfaces too easy to be ignored in the design phase?

User roles

Let’s concentrate on graphical user interfaces. What should a user interface design process be like? The user interface design shoud start with determinig the different user roles of your application. For example you may need to have a different kind of user interface for the end-users as you do for the administrators.

Views of your user interface

After you have indetified different user roles you should list the main tasks a users in different user roles uses your application. It’s important not to go into too much detail, just concentrate on the most important tasks. The number of main tasks depends on your application. Determine what kind of views do you need in your application to allow users to do these main taks you have identified. You may need multiple different views such as monitoring view and configuration view and visualization view. Depending on your application, these views may be separate parts of a single window, different states of a window or separate windows.

Paper mock-ups

Once you have determined the main views you’ll need in your application you should not hurry to your computer and start coding. Instead you should sit down, take you pen and paper and start drawing mock-ups of your user interface. A mock-up is a model of you user interface. With pen and paper it’s easy and fast to try different variations of component locations. Also the drawing process helps you to concentrate on the important parts and not to go into too much detail too soon. You identified different main tasks the users need to do with your application. Go trough these tasks with your paper mock-ups. If there are major state changes in your views, don’t spare the paper. Try to cover all important views of you application and all important states of different views. Play around, all time consumed in the paper user interface design phase is well spend.

Usability testing

Next you should grap a small group of potential users and show them the user interface mock-ups you have made. Users tend to think differently from what you expect so it’s important to get into direct contact with the potential users. Show them your user interface paper models and ask them to proceed with the important tasks. Don’t help them too much, let them figure out by them-selves what to do, which button to press. Simulate the user interface functionality by showing them different pieces of paper. Use your imagination to find a nice way to simulate your user interface without a computer. Again, don’t go into too much detail, concentrate on the most important parts. If your test users don’t behave the way you would expect them to, ask them what would be the intuitive way for them to proceed with the tasks.

Hand drawn paper user interface models are an excellent tool for the user testing. In computer graphics based user interface models, the tested users tend to concentrate too much on the details and on the lack of polishing. With hand drawn paper models it’s evident that they are only models and users don’t expect them to be polished. Instead they concentrate on the usability and that is exactly what you want to test with them.

Don’t be afraid with the user test phase. You can really often find suitable test persons from your work or from your friends. Testing your user interface doesn’t take a lot of time but you get plenty of valuable feedback. With this feedback you need to go back to your desk and start considering how to make your user interface better, how would it serve your users better.

Conclusions

User interface design is an iterative process. Depending on the complexity of your user interface you may need to iterate the process several times. Only after you are happy with your paper models, you should start working on real front panel implementations. There are many ways of designing user interfaces and this particular process I learnd from useability experts when working on a consumer product project.

Take a look at Jim Kring’s related post on Human Interface Guidelines on his blog Thinking in G.

Scala is my favorite non-visual or text-based programming language. Scala is a functional object-oriented programming language has succeeded to combine almost all features I’d like to see in a programming language except the visual way of coding. Scala compiles to Java Virtual Machine and is fully interoperable with Java code. There was a nice introductory article on Artima a few days ago First Steps to Scala by Bill Venners, Martin Odersky and Lex Spoon. If you are into text-based programming, you should seriously take a look at this article.

In my last virtualization article Streamlined Software Development with Virtualization I discussed about benefits of virtualization and virtual machines on software development process. In this article I present how to set up an excellent free PC virtualization software VMware server to Windows XP host computer and how to install Windows XP client system on it.

Setting up VMware Server

VMware Server is an excellent virtualization software for software development. It’s feature rich, easy to set up and completely free. VMware targets VMware Server for light duty server virtualization and targets non-free VMware Workstation for software developers. VMware Workstation should have some extra features but unless you really need these extra features there is not any need to pay for them.

VMware Server can be downloaded from product homepage. To install the product, you’ll need to gain serial numbers. The serial numbers can be requested from VMware for free by filling-up registration form. Installation of VMware is very straight forward. If you don’t have Microsoft web server IIS installed on your computer, the installer will complain of the lack of IIS. The IIS is only needed if you want to manage your virtual machines over the network and for local only installation you can safely ignore this complain and press Ok to continue.

Creating A New Virtual Machine

After you have installed VMware Server you need to create a new virtual machine. Virtual machine runs on top of host operating system. It uses a large file as file system image, shares the host computer keyboard, mouse, monitor and network connection. To create a new Windows XP virtual machine you’ll need a Windows XP installation CD and a Windows XP license.

Start VMware Server. From an appearing pop-up window select local host to indicate VMware Server that you want to manage the virtual machines on your local computer and not machines on the network. From File menu select New > Virtual Machine. A wizard will start that guides you trough the virtual machine set-up process. After few initial options the first real decision you need to make is to choose the network connection type. Bridged networking is probably the best choice. If you are in a network where each computer needs to be registered for the network, then NAT networking will be easier as you don’t need to register your virtual machine to the network.

The second important choice is selecting the disk capacity. Set the capacity as high as you think you ever may need in this virtual machine, the capacity cannot be increased later on. Uncheck Allocate all disk space now option to keep disk usage at minimum. The disk will be allocated as needed. Finally click Finish button. The virtual machine will be created.

After you have created your new virtual machine you still have to specify the resources it may consume. Click your virtual machine on the inventory unless it is already selected. On the right-hand pane of the VMware Server Window under Commands bar you should have an option link Edit virtual machine settings. Press this link to open the virtual machine settings window.

On the Hardware tab set memory to 512MB if you have 1GB or more of system memory to guarantee Windows XP to run smoothly on the virtual machine. Then click on the CD-ROM settings and turn on the Connect at power on option. This makes your CD/DVD-drive automatically visible to the virtual machine. You need your CD/DVD to be visible so that you can install operating system and software to the virtual machine.

Now we are ready with setting up VMware Server itself. Let’s continue to installing the operating system.

Installing Windows XP on Virtual Machine

Installing windows XP to virtual machine doesn’t much differ from installing Windows to any other computer. Insert the Windows XP installation CD to the CD-ROM drive of your computer. Make sure you have a valid license with a Windows XP serial available. If you have autorun enabled on your host computer, ignore the window that will pop-up.

Make sure you have selected the correct virtual machine from the inventory on VMware Server control panel. Now start your virtual machine by pressing the Start this virtual machine link on the VMware Server control panel. The Virtual Machine should now start up, then connect to your host computer CD-ROM drive and start the Windows XP installer on the CD. From now on the Windows XP installation will proceed as normally.

Installing VMware Tools

After Windows XP installation has finished, there is still one more task to do before you can start using your virtual machine as normally. The virtual machine runs on top of the host computer and the performance is not optimal. All the graphics, mouse movements and key presses are transferred between the host computer and the virtual machine. VMware Tools is a package that should be installed on the newly created virtual machine to improve the performance of the host computer – virtual machine link.

On Windows virtual machines the installation of VMware Tools is very straight forward. On linux virtual machines you will need to recompile your kernel. When virtual machine is turned on and you have logged into it with administrator privileges, select Install VMware Tools from VM menu of the VMware Server control window. This will mount a virtual CD image and if autorun is turned on, an VMware Tools installer will automatically start. If autorun is not turned on, you’ll need to start the installer manually from the CD-ROM drive of your virtual machine.

Conclusions

Congratulations, you’ve now installed VMware Server on Windows XP and installed another installation of Windows XP on the virtual machine. To install applications to virtual machine, simply insert installer CD:s to your host computer CD-ROM drive and you can directly access them from your virtual machine. You can mount CD-ROM images on your host computer to your virtual machine.

It wasn’t that difficult, was it? If you are interested in getting some deeper knowledge on any aspects of virtual machines, please let me know. I can consider writing further articles on using virtual machines on software development.

I’m very excited to announce that Rolf Kalbermatter will be blogging a series of articles on LabVIEW external code interface here at EXPRESSIONFLOW. Rolf is a highly appreciated and active member of LabVIEW community. Rolf’s special areas of interest are in LabVIEW related low-level issues such as LabVIEW internals and external code interfacing. As a former employee of National Instruments, Rolf Kalbermatter has had an excellent opportunity to gain a deep insight to these issues. I’m very happy to welcome Rolf as an author at Expressionflow.

Multiple users have reported that they are unable to post comments to Expressionflow. The problem has been tracked down to have been caused by rich text comment editor that was used on this site. The rich text comments have now been disabled and there should be no more problems posting comments. Should you have any problems, please inform me. My email address can be found at the bottom of the page in the copyright notice. (Post has been edited!)