This LiveCode review is by Dr Jeroen Lichtenauer, programmer for the HandsOnTurkish project.
Livecode is a multi-platform programming language, IDE and compiler that is capable of compiling to mobile devices. The following evaluation is based on Livecode versions 6.6.2 and 7.0 (dp 6).
Flexibility
LiveCode is a very flexible, adaptable programming language. Even though Livecode has a graphical user interface to create objects such as buttons and text fields, all elements can be also be created, modified and deleted from the programming code itself during runtime.
Because objects contain programming code as their editable property, even the program code itself can be changed by the program while running. This is very useful to create interactive objects on the basis of an XML specification, where not only content but the number of objects has to be adaptable.
Using the iOS externals (http://livecode.com/developers/guides/externals/) or modifying the LifeCode software itself by using the open source version, LiveCode can be extended with modules written in C or C++ that make (better) use of platform specific features that are not (yet) available from LiveCode itself.
The procedure of modifying the LiveCode open source version (which is required for adding unsupported functionality on Android devices) is difficult and largely undocumented. However, this is about to change soon, as LiveCode is working on a next generation of LiveCode that will make it much easier to add externals. This will not only make it possible to add your own functionality with basic programming skills, but it is also expected to lead to a rapid increase in the development of third-party plugins and in the frequency of LiveCode updates that integrate some of these plugins into the main LiveCode software.
Ease of Use
Livecode is advertised as a very easy language to program applications very quickly. In our own experience, we found this to be slightly deceiving, or at least a limited view. Yes, it is possible to make an app quickly in a drag-and drop style using the graphical interface of livecode. However, this is only true if you make a deterministic application that runs in only one screen resolution and aspect ratio. An app can be stretched to higher resolutions, but not reduced to lower resolutions. Programming your own screen-adaptation functionality is recommendable
The e-learning tool needs to load its contents from an XML file, to be able to add and change content easily without requiring any software programming. Furthermore, desktop computers and mobile devices come with numerous different screen resolutions and aspect ratios. Because of this required adaptability, we have found that it is not realistic to program the e-learning application using the graphical user interface of Livecode. Instead, we have found it more suitable to (re-)create all screen elements from code upon opening a page of the application. In this way, programming a graphical user interface with livecode is more similar to programming a webpage with html and PHP, where the placing of elements is done by specifying (relative) pixel locations and dimensions of objects.
Multi-Language Support
Livecode has been limited in the support for languages that contain characters different than the English alphabet. Currently, the use of Turkish language is possible in text fields as well as titles of objects and windows, using unicode. Since the release of Livecode version 7.0 in March 2014, there is full support of foreign languages, including right-to-left script. We have not tested this ourselves yet, though.
Reliability & Bugs
Livecode is updated frequently and there is an active community sharing solutions to problems. During my evaluation, a new Livecode release was published several times a week. However, most of these releases were not stable, thoroughly tested versions. A new release that is called “stable” was published much less often.
Note that as of LiveCode version 6.6.2 RC 4, image scaling defaults to lower quality. This might give disappointing results, but can easily be fixed. To get an acceptable quality of scaled images, the resizeQuality property of each image has to be changed to “good” or “best” instead of “normal”.
We have come across two unresolved bugs in Livecode that are worth mentioning to those who might consider using LiveCode in their own projects:
1) On Android, the initial orientation is not adjusted to the actual screen orientation (follow its progress on http://quality.runrev.com/show_bug.cgi?id=11146). After manually rotating the device and back, the orientation is corrected. We have thus far not found a workaround for this, but it’s a problem that the user of the application can easily self-correct.
2) When using automatic full screen stretching on Android, Livecode does not call the function that is needed to adapt to a different orientation (follow its progress on http://quality.runrev.com/show_bug.cgi?id=12023). The workaround for this is to simply not use the full-screen stretching mode, but instead work directly with the true resolution of the device and manually resize and relocate all screen elements according to screen size.
Platforms
For all platforms, the free version of Livecode requires to supply the source code of an application as well. This practically limits the usability of the free livecode version to making free software, since selling software together with its source code is usually not a viable option.
Desktop
Livecode compiles to Windows, Linux and Mac. We have tested it on windows only. When run on a desktop, a livecode app can work in a window as well as full screen. In full screen mode it hides the taskbar of windows even if the taskbar is set to stay on top.
Mobile
Livecode can be compiled for Android and iOS (iPhones and iPads). Playing sound and video needs to be programmed slightly different than for the desktop. This can be adaptively done by including both ways in one program and let the program choose the right one on the basis of whether the environment variable “the environment” is set to “mobile”. Some user interface controls might also have to be adapted to the mobile environment.
Because of the limited screen size of some mobile devices (especially phones), not all exercises might be possible to do on mobile devices.
Compiling to Android
Compiling from Livecode to Android can be done in Windows, Mac as well as Linux. It requires the installation of the Android SDK and the Java JDK. The Android SDK includes an Android emulator that allows testing an Android app on a Windows PC. However, the Android emulator runs very slow, causing a significant loss of programming time. Running the Android emulator with an Intel Atom architecture is faster. However, apps compiled with LiveCode can only run on the ARM architecture (this is a Livecode limitation). Testing on a real Android device is therefore highly preferable over using the Android emulator.
Compiling to iOS
The iOS externals possibility of LiveCode makes it possible to write new modules in C++ that make (better) use of iOS specific features.
Compiling to iOS (and compiling externals) can only be done on an Apple Mac computer. This is not different from programming for iOS with XCode, since that can also only be done with a Mac computer. Compiling to iOS cannot be done with the free version of livecode.
Compiling to Windows Mobile
Currently LiveCode cannot compile to Windows Mobile devices. However, this possibility might be added in the (near?) future: https://www.kickstarter.com/projects/1755283828/open-source-edition-of-livecode/posts/415346
Web
Unfortunately, it is currently not possible to compile Livecode to an application that can be used through a web browser. However, LiveCode has succeeded to get funding for the development of the delivery from LiveCode to HTML5. They expect this to be ready by the end of 2015.
Currently there is already a separate program/package called “Livecode Server”. This has to be installed on a web server and works similar to PHP. Programming with Livecode server is done in HTML in which script is inserted using tags. Since it runs on the server, it relies on new page requests for user interaction, just like PHP.
Even though the syntax of Livecode Server is similar to the syntax of LiveCode, an application created with livecode cannot be converted to Livecode Server. It has to be recreated from scratch.
Until the HTML5 version of LiveCode is ready, programming in HTML and javascript directly is the only option to make an application that runs on the user’s own browser instead of on the server. Nowadays, javascript is sufficiently powerful and flexible to be able to implement the e-learning course Turkish. However, unless someone is using a public PC, downloading the standalone application compiled from livecode for their platform is always an option.
Alternatives to Livecode
There are other multi-platform application development tools, such as Phonegap and Titanium Appcelerator, that use HTML, CSS and Javascript.
The advantages are:
- The same code can be used to make a web application as well as mobile and desktop applications.
- No new programming language to learn, apart from the functions to access mobile features such as accelerometer, contact lists, etc.
- Easy to reuse code when switching to another javascript-based app development tool.
The disadvantages are:
- Slow response, due to the embedding of script that makes use of the java engine, which means extra computational load on the already limited processing- and battery power of a mobile device.
- Applications have the look and feel of a website rather than a true app. Several reviews of apps made with these tools report that it is easy to tell that the apps are made using Javascript/HTML.
- Difficulties reported with adapting the app size exactly to the screen size.
- Compatibility with different devices is poor
Conclusion
The paid version of Livecode provides the essential functionality that is needed to make desktop as well as mobile applications for the e-learning course Turkish. The free version is practically limited to non-commercial applications, because of its requirement to provide source code, and excludes deployment to iOS devices.
Livecode is not able to produce online (in-browser) applications, yet. For this, javascript is the most flexible option since this has advanced graphical capabilities. Furthermore, javascript runs entirely on a user’s own browser/computer and thus requires little server CPU load. An appropriate CMS (usually consisting of a mixture of HTML, PHP and javascript applets) is probably the most realistic option for making web applications.
Postscript
Since writing this review, LiveCode has made substantial progress with Version 7 which solved many bugs and issues, as addressed above. LiveCode has also had their HTML5 package kickstarted with a staggering investment of almost half a million euros. Both the project and the sum of money indicates that LiveCode will endure and has substantial backing.
The HandsOnTurkish team was recently interviewed by LiveCode, read more here:
How to be hands on with LiveCode
The new EU-funded HandsOnTurkish project gives individuals and businesses the chance to acquire Turkish for vocational purposes and gain a better awareness of Turkish culture and business etiquette.
Businesses can access the free HandsOnTurkish eLearning course – available online or downloadable for iPads and smartphones via the Apple and Android Appstores.
Thank you for visiting HandsOnTurkish. Our award winning interactive courses of Turkish have been developed for anyone with a genuine interest in the Turkish language and Turkish culture, whether for private, educational or professional reasons and are specially designed for self-study. Our website and our language courses are free from advertisements and we don't share any personal details of our visitors or registered members with third parties. Nor do we sell data for targeted advertising. We believe passionately that learning should be free from commercial distractions. For this reason we rely on subscriptions to fund the development of our products. Click here to find out more about our online Turkish courses.