“Computer users with rudimentary skills will be able to program via screen shots rather than lines of code with a new graphical scripting language called Sikuli that was devised at the Massachusetts Institute of Technology. With a basic understanding of Python, people can write programs that incorporate screen shots of graphical user interface elements to automate computer work.”
That programming by any GUI method (or anything that purports to make it easy and simple enough for idiots to do it) will give far too many people the idea that since they can use the interface, they can write meaningful, functional applications that work. Sadly, no such user interface advance, no amount of iconography, absolves people that are creating software from having to think logically about things, and figure out how things need to work to be efficient, and what’s needed to have things properly checked for errors and the like. What comes to mind is Microsoft Bob: looks nice, but ultimately, it may add more to the whole scheme of things in needless complexity with no solid benefits.
It’s a neat theory, but the proof is in the practical application. In the right hands, it may make them more productive, but then again, maybe not: in the right hands, they don’t need it to start with!
Most novice programmers confuse programming with coding (which is just a part of programming, and programming is part of application development).
By the way, the idea you’ve come up with is nothing new in particular. Since PCs are everywhere, every idiot (sorry) who does not confuse the mouse with a foot pedal is confident that he is a professional system administrator. The result? More and more idiots in sysadmin business, occupying precious working places and causing wage dumping: “Why should I pay you to service our company’s network systems? My 10 years old son can do it!” – and the son (in this example) of course can’t, so the network crashes, causing much more costs. Just because they can click on funny pictures doesn’t mean that they have any clue about computing.
I know, it’s the pure hatred speaking from me. 🙂
At university, I was told by my old professor: “Trial & error is not a programming concept.”
Allthough graphical access methods really have potential and are quite important in application development in general, as well as in support coding, they are not the ultimate and only solution existing to every development problem.
If you don’t understand the basics, GUI elements surely won’t help much. Of course, they can be part of a teaching process, but learning to be a application developer is more than clicking on funny pictures.
I agree with this. Any helper program, be it GUI driven, by voice or by whacking a mole with a hammer, is just a tool. It doesn’t do the job for you. In can be of immense help if you know how to use it properly, but it can destroy everything if you’re just too plain stupid.
why do you say programming by GUI “will give far too many people the idea that since they can use the interface, they can write meaningful, functional applications that work”
what a strange thing to say, you must be angry
software-developement without coding is already in wide use
it’s called labview
Indeed, I fail to see how this difference something like Microsoft Sketchflow or LabView that you mentioned. There is also lot of other rapid development tools that do same as this MIT “picture-driven programming”. I also think that whole name is wrong. This is automatic code generating PDD. Same as if I write specification on BDD(behavior) at paper it is pure BDD, but if I use tool that then generates tests from that BDD document it would be automatic code generating BDD.
Hmm the closest thing to GUI programming I have done is using a RAD tool and it’s great but many times things have to be created dynamically in code such as when you create a new tabbed document you have to create a new tab. The tab bar though can be created in design time but you can also do it in run time and attach events.
Now that it’s possible to create a program via use of screenshots, maybe we can use this technology to write drivers based on recognising what hardware is in the system?
(Note: You might not understand that joke unless you read the “brainstorm” forum on Ubuntu Forums)
Might be best if you supply a link to your obscure reference
This whole concept is ages old.
There’s been game development environments based around this concept (names of which escape me) and you could even argue that some multimedia presentation packages like Adobe Shockwave/Director and Flash were based around this idea too (given their aims of flexibility)
Each time, the idea has fallen flat on it’s face because you just can’t build the complexity of functions a creative mind demands without resorting an overly complex interface or scripting (as Shockwave and Flash have done in their later incarnations).
So good luck to the MIT guys, but I can’t see this being much of a useful tool beyond perhaps replacing .bat or *nix shell scripts in the minds of some of the lesser-experienced system admins.
Hi,
While I agree with almost everything you said; I’m not convinced that it’s impossible to create a graphical programming environment capable of handling complex functions, etc.
I’m from an assembly language background, and from my perspective there’s only about 8 basic operations – move, add/subtract, multiply/divide, and/or/xor, “branch_on_condition” and call/return. Things like shift/rotate can be done with multiplication (and then converted to shift/rotate by the optimizer), and things like do/while, for/next, switch, etc can be done with “branch_on_condition” (or the reverse – have all the high level stuff that’s converted to “branch_on_condition”).
Mostly I can imagine a main screen where you create variables, arrays, etc. You could select a variable (or array element or whatever) on the main screen, then select an operator (from a ribbon/icon/menu at the top), then select another variable on the main screen; and the environment would perform the requested operation on the selected variables and add/insert the operation to the function currently being edited. With a little care it’d be easy to put together something as powerful as ANSI C (once you fill in all the gaps, add variable names, comments, scope, etc), with the added bonus that you could see exactly how each operator effects each variable as you “write” the code.
-Brendan
Fair point, but what you’ve done is replace text with icons – the structure is exactly the same thus I can’t see it being any easier to use than the ASCII equivalent.
In fact, one could argue that, as characters are just pictures themselves (albeit very simple representatives for sound), that your method is the same as standard text programming (granted I’m really stretching the laws of logic here to make a point)
I think if you wanted to make a pictorial programming language, you’d want to do away with the structure of ASCII languages (which is what scares people) and build something more flow-chart/circuit diagram orientated.
Actually, I’m almost tempted to build my own language now for “fun”…..
From the video posted on their website, this looks basically like Expect for GUI’s– not a programming language meant for building applications from scratch.
I may actually have a use for this. I am forced to use a horribly designed internal application across a high latency internet connection. If Sikuli works as advertised, I could automate some of the slow, repetitive tasks that I need to do. So, instead of spending two hours clicking, typing, clicking, clicking, typing… I could just feed it a CSV file with the correct data to input and let Sikuli do the work.
Again, this functionality has been around for a while.
At work we have an application called Dataload which is exactly that.
I also built a .NET application that uses “sendkeys” to communicate with another app which has a dreadful interface.
There were Amiga programs CanDO and Amiga Vision.
Both software 14 years ago made the same things that Mit developed with Python language but using very simple icon driven interfaces that calls multimedia functions and using AReXX language (for the complex programming).
http://krystynascreations.us/ebay_photos/amigavision.jpg
http://encanta.avalonsoftware.org/idgaw/43/dib/softmulti5gr.jpg
Programs of Amiga Vision were intepreted and required Vision Player to be seen without the interpreter.
CanDo programs could be complied by CanDo itself and beacame indipendent from the author software.
Also last versions of Scala! Multimedia were capable to create little running programs by assembling icons and events in a timeline.
Actually on Amiga there is Hollywood that received this inheritance and is far better that any of these old programs, and can create indipendent complied software capable to running on Amiga, MorphOS, AROS, Windows and MacOS X (PPC or Intel based).
http://www.airsoftsoftwair.de/en/prod_hollywood.html
http://www.airsoftsoftwair.de/images/products/hollywood/shot14.jpg
(simple driven interface for gradients)
http://www.airsoftsoftwair.de/images/products/designer/shot10.jpg
(autoforms)
Seems me that at MIT they just reinvented the whell.
Going to the original source – the MIT paper it-self – the goal appears centered on automated scripting for GUI useability testing. It appears possible that the framework could be used to craft and optimize the GUI building-blocks and their inter-relationships for an application. However, GUI-based code generation was not the original intent/purposes.
By-the-way, I (and likely many other users) have long lists of examples of (frustrating) poorly implemented application GUIs.
There are many tools availiable that use graphical object to develop programs. For example, many ETL tools like Datastage, Data Integrator etc.
I tend to agree with most of the comments on this post that this project is a nice concept but far from programming, and not quite the automation of work flows either. We’ve been using Nolio for our application deployments and maintenance and for smaller clients, the Nolio Express version (www.nomorescripts.com). The nice thing about Nolio (www.noliosoft.com) is that the interface is drag-and-drop, and we can easily create workflows that has dependencies between application tiers (e.g.: restart tomcat only after database servers have been updated).