As I understand it, the visual programming in LabView and MatLab work quite well. These, I believe, will be your primary points of comparison.

The only reason why I would attempt to do something in Labview in the first place is because all the hardware manufacturers ship with LabView modules.

What do you think your visual environment has to offer over a textual language without a lot of cruft and with relatively "simple" syntax?

I am in no way trying to get any current developer to switch over to building programs in WizBang. This was never an intention. The goal is to present a simple, minimal, visual environment in which to build simple programs.

After the beginner learns the basics, WizBang eases them into the next step of learning a real language, such as C++, Java, or Python, by allowing them to compile their WizBang programs into valid code in any language that's supported.

To answer your final question: the only advantage WizBang has over a textual language is that I think there are more grade school (and even high school) students that would experiment building programs with colorful shapes than typing commands into a text editor, then running a compiler or interpreter to see what they get.

See this system I've built for teaching binary search tree algorithms. You can use it to teach not just basic binary search tree algorithms but also AVL and red-black tree algorithms.

http://opsis.sourceforge.net

You might want to compare http://scratch.mit.edu/ for some UI inspiration.

I've worked a bit with graphical dataflow systems (like LabView) that can actually realize a much quicker time to operation than hashing out equivalent code by hand.

But speed is not the point at all in WizBang. The point is to present a clean and simple environment in which beginners can build real programs without having to type more than variable names. I feel it is a much easier way to introduce programming than having someone install Visual Studio and writing a hello world program.

There have been a few attempts at pushing the complexity down so that non-programmers can work with complex things. Like Data Flow programming systems for example.

Showing somebody how to build a simple data processing app in one of these systems is very rewarding as they realize they can coax the machine to do what they are telling it. But I've mostly dealt with adults, not kids.

Maybe add some graphics capability a la Logo? That way, you can see the turtle and the program going at the same time.

Also, some kind of labelling/commenting of the different "areas" of the program -- that can then be translated to comments to the code.

I think I have been fleshing out an idea like what you are suggesting from the turtle cursor. I would like to add a step-by-step debugging to WizBang that allows the user to watch variable values and step through each Wizzy (with it being highlighted graphically). If I implemented that, I think it would be a great way to visualize different sorting algorithms.

Edit: I'm also not quite a computer scientist! College drop out! :)

I went to Virginia Tech and since the CS department was sucked into the rest of engineering - I ended up taking intro engineering courses (read: a complete waste of time) and they wanted to teach programming to freshman engineers through Alice.

Alice, although the early versions crashed, ran slow, and often saved the XML 'world' files incorrectly, corrupting your work and making you lose it - it did a great job of teaching visual programming because you could easily create a 3D scene or game without much effort, plus it highlighted the code as it ran.

While Wizbang is visual as well (albeit in a different way), the program flow diagrams kind of look like UML diagrams and could STILL scare away novice programmers.

A main issue of teaching programming to new comers is you need to start with the basics - but printing "hello world" to the screen doesn't seem applicable so it feels like they are wasting their time. Besides, most of what they use computers for is pretty and visual.

Wizbang doesn't seem to offer anything else that other learning tools don't do in a better way - except maybe the export to a "real" language.

Now imagine if you could combine that exporting functionality on top of something more visually interesting like Alice. Make a 'game' in Wizlice (Wizbang-Alice), and then export that code (on top of your minimal graphics libraries or functions to support what they write) to C++/Java and let them tinker around with THAT... they'll be on HN in a couple of years tops.

Cool idea, polished effort, please expand visual component!

Visualizing the exchange of messages in object systems is just as hard. I think that that is a big impediment to teaching OO. Perhaps that's a bit more advanced than what this project is after.

I applaud you for your concern and effort, but I wonder about the unintended consequences of this. Do you really want to encourage someone who would be "scared away by compiler errors"? Compiling is easy, deploying is much harder.

If someone is scared away by the easy stuff, how will they respond to the real difficulties that await?

Maybe I'm a little old fashioned, but I think the battle scars earned conquering the little things like syntax help build a better programmer for everything else. I wouldn't want to take that building block away.

I wonder if syntax errors could be made friendlier by animating them as visual pieces that don't fit together or that do not stick? I can imagine an editor that always keeps the text syntactically correct (by adding in closing brackets, boilerplate text to be typed over, etc). A visual editor that behaved in the same way would be very useful. Especially if the program code would dynamically update in a parallel window!

I think that people can relate to some widget or puzzle piece fitting or not fitting onto another widget or piece. Certainly, one can relate to this more readily than cryptic messages like "syntax error."

Well, that remark certainly devaluated my opinion of grad schools. I understand not everyone is fit for SICP at 18 (I certainly wasn't), but this is quite on the opposite end.

I know at least one would-be programmer who is not scared away by complier errors, but he is almost comically infuriated by them: not their presence, but their customary vagueness and unhelpfulness. Such a tool as this might provide an intellectually curious sort like him to learn proper syntax for common programming concepts without having to dig through man pages or web pages, and without lots of trial and error.

If you are serious about this, you should dig up those previous systems, and see if you can come up with a reason why your system will fare better. I will concede I am pessimistic that such a property can exist, but who knows if I am correct? But if you really want this to succeed by any measure, you really really ought to do this.

Or decide you totally don't care about success, by any measure you choose, in which case, have fun. But I can't in good conscience just blindly encourage someone when taking on a visual programming language. It's like happily encouraging someone to go ahead, leap off the diving board into the pit of spikes, no problem, everything will be fine. We're taught by our culture to blindly encourage everybody, no matter what, but such encouragement has consequences. We shouldn't ignore those consequences.

If I had to pick the most likely angle of attack for such a system to stand out from the crowd and potentially enable some sort of interaction that might help you escape from what appears to be a total black hole of effort, it would be the input device. The mouse and keyboard have been explored on this front. Perhaps a stylus-based system could do something different and new, or something. (Touch will probably be too imprecise, it virtually drops your resolution and you're going to need more precision, not less.)

For example, my girlfriend took the intro course and did pretty well but they moved on to real Java and object oriented programming she felt like she had wasted 1/4th of the semester on the visual programming aspect, and would have much rather just learned the normal way.

I think a better way to approach this is to design labs that are both easy, educational, and satisfying to the student. This isn't that hard to do with the numerous graphical libraries that simplify programming for the student.

The visual programming idioms that Ive noticed having some impact are things like dragging connection points to wire up inputs/outputs or behavior/function calls.

If you look at modern visual GUI design tools such as apple/xcode Interface Builder, wiring components seems to be something that beginner users could understand easily. [Have a look at recent demos from 280 Norths Atlas to see this taken to the web]

Maybe you could work with a school computer hobbies class as an ongoing project to see how they learn in practice - perhaps offer it as a visual logic puzzle?

They use PLT scheme as the core of their system, but decided to implement it in JS to eliminate difficulties young kids would have installing software, and to simplify sharing of programs for bragging rights (for kids, of course - no adult programmers care about such things).

Edit: scratch, not squeak

Lest we forget that COBOL and SQL were originally designed to be accessible to non-developer business-y types. One wonders how much UX testing they underwent.