DougKU

I have had success virtualizing XP and other Linux distributions on a Fedora 11 host using KVM. I benefit from a academic site license for NI products so I use LabVIEW and other NI products on all. I use snapshots to return to a clean install of XP and LabVIEW to test an installer. I have had instances where third party software requires a specific version of NI-DAQmx or traditional NI-DAQ and have been able to use the VMs to recreate the problems and sometimes find solutions.

Does anyone know what to run to virtualize OS X with LabVIEW?

I don't know how important OOP and XControls are to your overall project, but that statement above bothers me a little. I don't see any reason why an intelligent, motivated person couldn't be writing their own stand-alone programs after a year of LabVIEW, even if it is once or twice a week. I will concede, though, that it all depends on the nature of the programs; mine are typically short, small-scope utilities for number crunching and display.

Are we still talking about the non-programmers? And by non-programmers, are we talking about science/engineering students who just haven't had a formal programming class? Or are we talking about humanities majors?

What is the purpose of this? To teach them LabVIEW? To teach them to program with LabVIEW as the chosen language? To do the subject matter work, with the programming just a tool? To have them contributing to your long-term, on-going project?

If it's the 1st two (and maybe the third), then I believe your LVOOP approach is teaching them to run before they've learned to walk.

I would be concerned about students (especially non-programmers) losing interest somewhat if they feel like they are getting lost in the minutiae, or don't see the end product of their work.

I am in a position where I am becoming a bottleneck. My model had been: Professor A approaches me with a project, I meet with them and then the involved graduate students and come up with a specification, then I produce an application that they can use. I do this frequently, so I am building a large library of code in my repository. With every new project I add new code and improve previous libraries that I am integrating. I have made frequent use of producer/consumer loops and functional globals (action engines).

I am always looking for ways to improve my shop's productivity. This year has been fun because I have been learning LVOOP (a little Endevo too), and OOP in general. The biggest benefit so far has been being able to talk more productively with the programmers around me who primarily use C#, and C++. I can hire a student for 10-20 hours per week. I can also pay for them to have LabVIEW training for fundamentals. However, I can't keep this individual for very long- maybe 2 years if I am lucky.

So from the beginning I have been considering how to get non-engineering graduate students to be able to play a significant role in the programming of their projects. The students vary in their backgrounds, and are from the Neuroscience, Speech Language and Hearing, and Psychology departments. It is very likely that these students will take more than 7 years to complete their PhDs. Projects vary from design of new sensors and actuators controlled with a Compact Rio, to online calculators with the internet toolkit or web services, to stimulus presentation for fMRI or ERP/EEG/MEG, to converting file formats from one proprietary application to another, and more. Targets have included Compact Rio, LabVIEW RT, Linux real-time, Mac, Windows, and Linux. The students usually have some background in scripting and may have even had a semester of Matlab. Sometimes they are expert at Sed/Awk and are capable of creating regular expressions. Many times their lab has purchased a very expensive system with the very expensive software that goes with it. Sometimes the software has an SDK. Sometimes it can be scripted with Python, sometimes Visual Basic, sometimes it might even have LabVIEW under the hood. The student will usually become an expert at this system.

The approach that I have seen in engineering departments has typically been to learn a programming language and develop the programs that you need to complete your project using as much available code as is possible. If you are lucky previous students have created a framework that you can use. In the end it is your project and you have developed and integrated the hardware and software.

I am considering a system where the student wouldn't create an entire application- that's what I do for them, but would create one part of the software. Presently they usually write the documentation for the end user, who might be another student in their lab, or a researcher elsewhere. This has proved to be a very effective way to give me more time. Now I would like to get them to write code that I can integrate into my existing framework and learn LabVIEW so that in the future they will be able to extend what we have done. (Almost all code will be open source and available to then in the future.)

So these are my goals:

1. Get others to create code that I can reuse.
2. Help students learn LabVIEW so they can extend the software in the future.

I think it was dead anyway

Indeed. I believe LV OOP was invented to give C++ programmers a warm fuzzy feeling and entice them to use Labview.

The advantage for beginners that Labview brings is that they are able think in a sequential manner to start with and lay down code in the same order as their thought process when analysing problems. This means that they learn the environment a capabilities of LV quickly whilst still producing tangible results (i.e code that works) without being encumbered by how it works. Once they get used to using LV as a symbolic "scratchpad", they quickly move on to more complex subjects as a natural progression. They also don't have to worry about pointers, memory management and all the other obnoxious stuff that makes other languages so flexible so their time is spent on the problem rather than managing code.

However, if you sit them down and explain that you have to spend 3 weeks writing code with (from their point of view) no discernible benefit apart from being able to make other code work. They quickly get confused, frustrated and bored. If they can sit down and in 10 minutes turn a light on and off, or make the computer beep every time they walk past it.....then you have an audience

This is true. But when it doesn't give you what you were expecting, then you do!

Just because a program contains objects (C++ .net or anything) doesn't mean it is an object orientated program. Non OOP programmers view these objects as "functions" to extract whatever data they need. They (I? ) mainly view them as a container with specialised features not dissimilar to a vi with a case statement that enables selection of a series of sub vis. This view is far less abstract and easier to digest for virgin programmers.

I have been thinking about how I will use LVOOP with beginning programmers that will work with me. I will use LVOOP and not any other OOP because LVOOP is by value, comes as part of LabVIEW and is not an add on. Then I will introduce the LabVIEW class. This leads very naturally to using the LabVIEW project and version control. Anyone that works with me needs to be able to use Subversion and the project so I will introduce them on the first day. I will provide a well structured project that they can check out and we will create a child class. Then I will spend time over the next months teaching the LabVIEW that is necessary to create the members of the child class. This will be the same non LVOOP with the following differences (there are probably more that I am not yet thinking of): instead of type definitions we will use the Class ctl private data, I will use Xcontrols early on, I will avoid functional globals. We will use libraries but the important features of libraries will be learned through the class which is a special library.

I expect that after a year no one will be able to build a program on their own, but they will be able to build a class including the Xcontrol. They will see how the class fits into the class hierarchy that I provide, and they will be able to see and understand many of the decisions behind the higher level design patterns that I am using. They will effectively use the project and version control system, and will have an understanding of using unit testing. I will be creating the test code for their classes, and providing feedback after nightly builds of all software.

My goal is to get programmers to reduce my workload by producing quality, maintainable, tested code that I can use. I expect that their outputs will be child classes and Xcontrols. However, I agree with you about needing to make things beep! To do this I will be providing the project that can already has a great deal of interesting functionality. The beginning programmers will add the specific (or at least parts of the specific) functionality to make the project hum.

Thoughts?

As a non-OO programmer (LV or otherwise), I think this is only true when trying to teach programmers. IMHO, if you try to teach non-programmers OOP, you're adding an extra layer of complexity that they have to learn. To me, understanding what a For loop does is much more intuitive than trying to understand classes, inheritance, etc.

I think I am hijacking this thread. I am also confusing the issue. I am pretty sure that OOP of some form in LabVIEW is more attractive to an OOP programmer from another language than no OOP in LabVIEW, but I too am uncertain about using LVOOP with beginners. I am a very poor OOP programmer that is really enjoying learning. I think LVOOP is a tool that I can use to simplify coding for others. I will try the experiment.

I think that LabVIEW objects can be used without adding the complexity you talk about. I also point out that non-OO programmers are usually very comfortable using C++ and .Net classes in LabVIEW. You don't have to know how to create a class to use a class.

But I am sure there is a topic about this elsewhere.

That's where your problem lies. I find it takes 1-2 months for a non-programmer that is eager to learn. You spend 6 months listening to text programmers whining about how they used to do it.

I am about to try the experiment. I will teach non-programmers and see what happens. I am pretty sure it will work out well, certainly for the ones that use NI hardware.

The Java programmer that worked with me was excellent and didn't whine. She really liked the event structure and case structure, and was happy to learn a lot about functional globals. However, it takes more than 1 o r 2 months at 10 hours a week to learn any programming language. I wish that I had been able to use LVOOP at the time because she thought in classes and interfaces. I really think that LVOOP will simplify learning LabVIEW.

This is my first post to Lava and not what I expected to be writing about, but I realize that many of the issues in this thread are actually very important to me. I work at the University of Kansas and have the benefit of the NI Academic Site License. I pushed the purchase of this license through KU because I saw it as a great value while I was at Duke where I started programming in LabVIEW in 2001.

While I was at Duke I was working with control theory so LabVIEW and Simulink were my tools. However, from the beginning I felt that I should get as much of the code to work in an open source development environment, and began a parallel exploration into Linux- a process that I continue to this day. As I have become a better LabVIEW programmer (especially since using LVOOP), I have become more comfortable being a programmer in general (not my background), and less afraid of diving into Python, or using C++.

In my job, I provide software and instrument design support for about 8-12 faculty and their graduate students. I am not in the School of Engineering but instead work with Neuroscientists, and Psychologists (LabVIEW and NI DAQ devices were being used in at least one lab when I arrived). Due to my familiarity with LabVIEW, the responsiveness of NI support, the availability of NI field reps, the need to port applications to multiple platforms, and the need to develop DAQ, control, and embedded systems, I decided early on that I was going to use LabVIEW whenever possible. I decided I would use LabVIEW as a general purpose programming language (because it is).

In general, I think my plan worked well, but for the problem of hiring LabVIEW programmers. Ideally I would hire students (graduate or undergraduate) that know LabVIEW programming. Many mechanical and electrical engineers use LabVIEW, but typically I find that they aren't yet ready to be programmers. Students from computer science generally have little familiarity with LabVIEW. I find it takes almost a year (10-20 hours /week) to get someone programming by themselves in LabVIEW even if they are very good at Java or another language. Of course I also have them learn to use Subversion, and a few other tools at the same time, but I think this is a good estimate. What is a shift register? How do you wire effectively? It takes time. I think LVOOP might speed this up...

So I am trying to make LabVIEW accessible to graduate students that aren't computer scientists or engineers. When the programming involves DAQ or control I am confident that I am correct in choosing LabVIEW. For other applications I am less confident. I am very aware that I am creating a dependency that they may have to take into their future academic or industry positions. When I create an application that they can install and use in the future I am not creating that dependency. However, when I teach them to use LabVIEW, I am ensuring that they will have to pay for a development package in the future to continue to be able to program using LabVIEW. I justify this in part because I think LabVIEW is a very good software to learn programming with, however it is actually a great concern of mine.

For myself I know that I will always have the choice to translate my code to a different development environment or purchase LabVIEW. I have always thought that it might be a good idea to have a license that a group of developers could share based on total time used. Something to allow someone that knows LabVIEW to use it on a limited basis without having to pay for an entire seat. Actually, this probably exists?