05 December 2016

Simple REST Server With Kotlin


With micro services being the latest important development in Software Engineering anyone doing server side development needs to be involved in this area. One of the major areas where Kotlin is being used is in server side development, especially micro services. This post will be covering how to create a simple REST server using the following technologies:


  • Gradle (any 2.x version)
  • Kotlin v1.0.5-2 (stable version)
  • Grizzly v2.3.28 (embedded HTTP web server)
  • Grizzly Jersey Container v2.23.2 (JAX-RS implementation for Grizzly)
  • Jackson v2.23.2 (JSON library)
  • Linux PC (using Debian, Ubuntu or Linux Mint)

Setup Project Directory

  1. Create a project directory called hello_rest_server
  2. Copy the Gradle wrapper directory and the gradlew file to the project directory
  3. In the project directory create a file called settings.gradle containing rootProject.name = 'hello-rest-server'
  4. Create a Gradle build file called build.gradle in the project directory containing the following:

-------------------------------------------------------------------------------------
group 'org.example'version '0.1-SNAPSHOT'
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:1.0.5-2'    }
}

apply plugin: 'kotlin'apply plugin: 'application'
repositories {
    mavenCentral()
}

dependencies {
    compile 'org.jetbrains.kotlin:kotlin-stdlib:1.0.5-2'    compile 'org.glassfish.grizzly:grizzly-framework:2.3.28'    compile 'org.glassfish.jersey.containers:jersey-container-grizzly2-http:2.23.2'    compile 'org.glassfish.jersey.media:jersey-media-json-jackson:2.23.2'}

// A Task to run the program.run {
    mainClassName = 'org.example.hellorestserver.RestServerKt'    //args = ["arg1", "arg2"]}

// A Task to create a JAR file for the program.jar {
    from configurations.compile.collect { zipTree it }
    manifest.attributes 'Main-Class': 'org.example.hellorestserver.RestServerKt'}
-------------------------------------------------------------------------------------


Text version:

-------------------------------------------------------------------------------------
group 'org.example'
version '0.1-SNAPSHOT'

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:1.0.5-2'
    }
}

apply plugin: 'kotlin'
apply plugin: 'application'

repositories {
    mavenCentral()
}

dependencies {
    compile 'org.jetbrains.kotlin:kotlin-stdlib:1.0.5-2'
    compile 'org.glassfish.grizzly:grizzly-framework:2.3.28'
    compile 'org.glassfish.jersey.containers:jersey-container-grizzly2-http:2.23.2'
    compile 'org.glassfish.jersey.media:jersey-media-json-jackson:2.23.2'
}

// A Task to run the program.
run {
    mainClassName = 'org.example.hellorestserver.RestServerKt'
    //args = ["arg1", "arg2"]
}

// A Task to create a JAR file for the program.
jar {
    from configurations.compile.collect { zipTree it }
    manifest.attributes 'Main-Class': 'org.example.hellorestserver.RestServerKt'
}
-------------------------------------------------------------------------------------

Create Kotlin Source Files


Create the following directory structure in the project directory, along with the kt files as shown below:

src
├── main
│   ├── java
│   ├── kotlin
│   │   └── org
│   │       └── example
│   │           └── hellorestserver
│   │               ├── HelloResource.kt
│   │               └── restServer.kt
│   └── resources
└── test
    ├── java
    ├── kotlin
    └── resources


To begin restServer.kt will act as the entry point file for the REST server, which will be edited first by adding the following code:

-------------------------------------------------------------------------------------
package org.example.hellorestserver

import org.glassfish.grizzly.http.server.HttpServer
import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory
import org.glassfish.jersey.jackson.JacksonFeature
import org.glassfish.jersey.server.ResourceConfig
import javax.ws.rs.ProcessingException
import javax.ws.rs.core.UriBuilder


fun main(args: Array) {
    val HOST = "localhost"    val PORT = 9000    val baseUri = UriBuilder.fromUri("http://$HOST/").port(PORT).build()
    var server: HttpServer? = null
    try {
        server = GrizzlyHttpServerFactory.createHttpServer(baseUri, createConfiguration())
        println("REST Server Address: $HOST:$PORT")
    } catch (ex: ProcessingException) {
        println("Server Error: ${ex.message}")
        println("Exiting REST server...")
        server?.shutdown()
    }
}

private fun createConfiguration(): ResourceConfig {
    val config = ResourceConfig(HelloResource::class.java)

    // Optional but good practise to manually specify the JSON mapping implementation to use.    config.packages("org.example.hellorestserver").register(JacksonFeature::class.java)
    return config
}
-------------------------------------------------------------------------------------


Text version:

-------------------------------------------------------------------------------------
package org.example.hellorestserver

import org.glassfish.grizzly.http.server.HttpServer
import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory
import org.glassfish.jersey.jackson.JacksonFeature
import org.glassfish.jersey.server.ResourceConfig
import javax.ws.rs.ProcessingException
import javax.ws.rs.core.UriBuilder


fun main(args: Array) {
    val HOST = "localhost"
    val PORT = 9000
    val baseUri = UriBuilder.fromUri("http://$HOST/").port(PORT).build()
    var server: HttpServer? = null

    try {
        server = GrizzlyHttpServerFactory.createHttpServer(baseUri, createConfiguration())
        println("REST Server Address: $HOST:$PORT")
    } catch (ex: ProcessingException) {
        println("Server Error: ${ex.message}")
        println("Exiting REST server...")
        server?.shutdown()
    }
}

private fun createConfiguration(): ResourceConfig {
    val config = ResourceConfig(HelloResource::class.java)

    // Optional but good practise to manually specify the JSON mapping implementation to use.
    config.packages("org.example.hellorestserver").register(JacksonFeature::class.java)
    return config
}
-------------------------------------------------------------------------------------

Above the host name and port number are stored in constants and referred to in the UriBuilder.fromUri function which creates a URI object. An attempt is made to start the server by creating an HttpServer object via the GrizzlyHttpServerFactory.createHttpServer function. Only 2 arguments need to be passed through, a URI and the resource configuration (ResourceConfig object).

Grizzly needs the resource configuration in order to know how to do the REST resource mapping. In this case the HelloResource class object (Java version) is passed as an argument to the ResourceConfig constructor in the defined createConfiguration function. If the server fails to start then a ProcessingException will be thrown. When that situation occurs the server error message is outputted to the console, followed by shutting down the server before exiting the program.

Now setup the REST resource mapping by adding the following code to HelloResource.kt:

-------------------------------------------------------------------------------------
package org.example.hellorestserver

import javax.ws.rs.GETimport javax.ws.rs.Pathimport javax.ws.rs.Producesimport javax.ws.rs.QueryParamimport javax.ws.rs.core.MediaType
import javax.ws.rs.core.Response

@Path("/hello")
class HelloResource {
    @GET    @Produces(MediaType.APPLICATION_JSON)
    fun getMessage(@QueryParam("name") name: String): Response {
        println("Processing request...")
        return Response.ok(mapOf("msg" to "Hello $name! :)"), MediaType.APPLICATION_JSON).build()
    }
}
-------------------------------------------------------------------------------------


Text version:

-------------------------------------------------------------------------------------
package org.example.hellorestserver

import javax.ws.rs.GET
import javax.ws.rs.Path
import javax.ws.rs.Produces
import javax.ws.rs.QueryParam
import javax.ws.rs.core.MediaType
import javax.ws.rs.core.Response

@Path("/hello")
class HelloResource {
    @GET
    @Produces(MediaType.APPLICATION_JSON)
    fun getMessage(@QueryParam("name") name: String): Response {
        println("Processing request...")
        return Response.ok(mapOf("msg" to "Hello $name! :)"), MediaType.APPLICATION_JSON).build()
    }
}
-------------------------------------------------------------------------------------

Above the HelloResource class handles the REST resource mapping for the /hello path (part of the URI). There is a single function (getMessage) which handles a GET HTTP request that contains a single URI query parameter called name. All that the function does is output a message to the console, and returns a message (as a HTTP 200 response via Response.ok function) in JSON (specified in the Produces annotation) form.

To start the REST server execute ./gradlew run in the project directory. Use the curl command to test out the server (eg curl localhost:9000/hello?name=Elvis). Exit the server using the Ctrl+c keyboard shortcut in the same console running the server.

20 November 2016

Kotlin Scripting


Many people won't be aware that Kotlin has scripting support, which includes the REPL. If you run the Kotlin compiler without any arguments you end up in the REPL (Read Evaluate Print Loop) environment, which is similar to Python's.

Kotlin REPL

Within the REPL basic expressions can be executed. Can even do block declarations. Some of the BASH keyboard shortcuts work, like Reverse Search (Ctrl + r) which will bring up the last line of code that was entered if it matches the search terms entered. As is the case with Python the order of code execution is from top to bottom. Currently documentation on Kotlin scripting is very scarce. The best place to look is on the Gradle website.

Kotlin REPL running code

Compilation time with each line of code that is executed is very FAST. So fast that there will be some situations where it is significantly quicker to try things (eg prototyping) out in the REPL rather than writing and executing a basic Kotlin program in a IDE. There is a file format called kts that represents a Kotlin Script which can be run in the REPL via the :load command. Can also run kts files using the Kotlin Compiler. Do note that the :load command does not accept a path to the kts file which contains spaces. Hopefully that will be fixed in a future Kotlin release.

For a more advanced/functional Kotlin REPL use the one provided by IntelliJ (is available in the open source Community edition). Despite being slower and not as stable as the original it does make it much easier to execute/manipulate blocks of code, and provides code completion as well as pop-up API documentation. Also all code is highlighted depending on the syntax highlighter that is used.

Kotlin REPL in IntelliJ

Kotlin REPL in IntelliJ - Running code

Be aware that you may encounter the infamous IDE lock-up bug where you do some code completion, and the IDE doesn't respond to keyboard and mouse events. Should such a situation occur then the IDE will need to be force closed and restarted. Not sure if the bug is fixed in the current IntelliJ Kotlin plug-in but be on the lookout just in case.

IntelliJ doesn't have a template for creating a Kotlin Script project so you will have to improvise by doing the following in IntelliJ:

  1. Goto FileNewProject…
  2. On left side select Empty Project
  3. Click Next button
  4. Enter in the project's name and location
  5. Click Finish button
  6. Goto FileNewModule…
  7. On left side select Kotlin
  8. On right side select Kotlin (JVM)
  9. Click Next button
  10. Enter in Kotlin for the module name
  11. Click Finish button
  12. Create a folder called src


A big advantage with the improvised Kotlin Script project is that you will have a clean REPL environment that only includes the Kotlin default imports by default. Also you have a central place to manage Kotlin Scripts should you want to keep existing code snippets to run in the future. Do note that kts files in the project cannot be accessed in the REPL (includes items like classes, variables, constants etc).

In an ordinary Kotlin project the REPL can access items (classes, variables, constants etc) from a kt file provided the source file is pre-compiled and is in a package. You will need to be careful when importing an item to avoid name-space clashes, especially at the top level.

Kotlin REPL in IntelliJ - Accessing module item

One last thing to mention is that Kotlin can be used for scripting at the terminal level via the kscript project. Below is a sample script from the project:

--------------------------------------------------------------------------------------------------
#!/usr/bin/env kscript
//DEPS com.offbytwo:docopt:0.6.0.20150202,log4j:log4j:1.2.14

import org.docopt.Docopt
import java.util.*


val usage = """
Use this cool tool to do cool stuff
Usage: cooltool.kts [options]  ...

Options:
 --gtf      Custom gtf file instead of igenome bundled copy
 --pc-only           Use protein coding genes only for mapping and quantification
"""

val doArgs = Docopt(usage).parse(args.toList())

println("Hello from Kotlin!")
println("Parsed script arguments are: \n" + doArgs.joinToString())
--------------------------------------------------------------------------------------------------


23 September 2016

First Look At Kotlin


Has been a long time since I found an interesting programming language which changes the way you approach solving problems in certain areas. Last time I was into JavaFX Script however it didn't take off as expected mainly due to the Java community not embracing it in general, the language was too specific (domain orientated), and not enough resources were being allocated to improving/supporting it. Also when trying to use JavaFX Script in projects the interoperability with the Java ecosystem (JPA, JAX-RS etc) often ended up being a show stopper.

By chance when looking at alternatives for Android development I discovered Kotlin. Kotlin is reasonably easy to learn with its difficulty sitting in between Python and Java. What ended up being really attractive about the language is its pragmatism/industry driven approach to software development. Many features in Kotlin are very well thought out with every single one being a result of Software Engineering experience in the industry (ICT). There aren't many programming languages that manage to balance conciseness with readability. You end up more often than not reading rather than writing code.

One of my favourite Kotlin features is Delegated Properties, specifically storing properties in a Map. Below is an example of this:




Text Version:

class Person(val map: MutableMap){
     var firstName by map
     var lastName by map
     var age by map
}

fun main(args: Array){
     val map = mutableMapOf(age to 20, firstName to Joe, lastName to Bloggs)
     val aPerson = Person(map)

     map["lastName"] = "Burke"
     aPerson.firstName = "Jane"
     println("Person: ${aPerson.firstName} ${aPerson .lastName}, ${aPerson .age}")
     println(Person age is Int: ${aPerson.age is Int})
     println("Map -> First Name: ${map["firstName"]}")
}



What you have above is an example of bidirectional Data Binding (sort of), which opens up a number of interesting real world applications like binding a database model (the model class, not the actual database) to a view. Despite the MutableMap using mixed types for the values it works just fine for the Person properties that rely on type inference via delegation. Blogger unfortunately doesn't have syntax colouring support for Kotlin code, is Google planning to fix this?

Some people view Kotlin as a statically typed version of Python however it isn't entirely warranted. If anything Kotlin is most similar to Swift. Even the language goals are very similar:

  • Concise
  • Safe
  • High performance
  • Versatile
  • Tooling
  • Interoperable

Kotlin documentation isn't too bad (the quality of the references is good) however it is seriously lacking a decent tutorial. Confusingly the navigation of the documentation section of the Kotlin website is all over the place. The Kotlin Koans for instance is in the Tutorial area instead of the More resources area. There appears to be a “Getting Started Guide” in the Reference area. If it is a tutorial then it needs to be moved to the Tutorial area.

Some Kotlin design decisions are questionable/controversial. Closed (sealed) classes are one decision which is very odd considering that there are a significant number of libraries/frameworks that rely on open class design, and Software Engineers frequently design software using an open class architecture anyway. Another one is Data Classes where some implemented functions are included for free (toString, equals, hashCode), and object de-structuring is automatically supported, which should be in ordinary classes instead. Using Data Classes causes severe issues (no class inheritance etc) that would be easily avoided by going with ordinary classes anyway.

Below is a list (not exhaustive) that shows who is using Kotlin:


Companies

  • Amazon
  • Google
  • Netflix
  • NBC (NBC News, TODAY, and Nightly News Android apps)
  • American Express
  • Pivotal (own Spring framework)
  • Expedia
  • Square
  • 3D Robotics (3DR Tower Android app not available in Google Play)
  • Basecamp (creator of “Ruby On Rails”), Basecamp Android app
  • Prezi
  • JetBrains
  • MongoDB
  • BQ (various Android apps not available in Google Play)
  • Meizu (various Android apps not available in Google Play)
  • App Foundry
  • GMC
  • Allegro Group
  • Bryx 911 (first responder Android app not available in Google Play)
  • Trapit (builds Android apps for some fortune 500 companies using Kotlin)
  • Farm Logs (Android app not available in Google Play)
  • Nulab Inc (Android app not available in Google Play)
  • Pinterest

Software Projects

  • Anko (official Android application development library for Kotlin)
  • Kotter Knife (Android view binding library for Kotlin)
  • TornadoFX (JavaFX library for Kotlin)
  • MapDB (embedded NoSQL DB for the JVM)
  • Requery (SQL query and persistence library which has Kotlin support)
  • Exposed (official SQL library for Kotlin)
  • Spec (official unit testing framework for Kotlin)
  • Kara (web framework for Kotlin)
  • Quasar (JVM concurrency library which has Kotlin support)
  • Spring Boot (micro services framework which has Kotlin support)
  • Gradle (version 3 onwards has support for developing plug-ins using Kotlin)
  • RxKotlin (RxJava bindings for Kotlin)

Android Apps

Kotlin Jobs (Possible Users)

One of the major surprises with Kotlin is the significant interest in the language from the Android Development community. Certainly helps when Jake Wharton (likely the most well known person in the Android Development community) is endorsing Kotlin. Many in the community want Google to support Kotlin as an alternative to Java.

In Fragmented postcast #20 an out of blue question was asked by one of the presenters, “When is Google going to support Kotlin in Android Studio?”. Why hasn't Kotlin been covered in an Android Developers Backstage podcast yet? Since late last year there have been a few Googlers frequently visiting the Kotlin slack channel, which has recently celebrated reaching the 4000 registered users mark.

As you can see it is highly unlikely Kotlin will be going away considering the sheer number of major companies and Android apps using Kotlin. If anything this shows that all Java developers should be seriously looking into using Kotlin for some projects if they haven't done so already. Kotlin is highly likely to represent the biggest change to the JVM landscape after Java 8.

27 September 2015

Moto G 2nd Gen Android 5.1 Update


Currently the Moto G 2nd Gen is on Android 5.0.2 and there is a maintenance release gradually being rolled out, however the release isn’t available to the XT1068 (network unlocked international variant) as of 25th September 2015. Maintenance release only fixes the StageFright issue and doesn’t provide an update to Android 5.1. While Motorola’s initial response to the StageFright issue is very good with providing information about the issue and a proper workaround their follow up has been very poor.

Motorola have been very slow in making the maintenance release available. So slow in fact that it is taking over a month so far to get the release distributed which is unacceptable. StageFright fix was released by Motorola for testing by mobile telcos on 10th August 2015, which isn’t applicable to the XT1068. Should only take at most a week to to distribute security fixes. Even then that is a bit too long when it comes to fixing security issues on a mobile device.

When it comes to finding out information about Android updates for the Moto G 2nd Gen it is very difficult to obtain the right information. Very hard to navigate Motorola’s website for software update information, and even worse when you do get there more often than not the information is inaccurate. The UI (User Interface) for the update section of Motorola's website differs widely between different countries. Why can’t Motorola use a single UI for the update section that applies to all countries?

Very quickly discovered that the Motorola Community forums are not an appropriate place to obtain update information, in particular on Android 5.1. For one thing while there should be some Motorola employees working in the forum occasionally. There is no clear evidence of this happening. Google get that part right on their forums where you can clearly see any posts made by Google employees. With Motorola anything goes, it is a real jungle out there. Any new thread created seems to get mysteriously removed if it is related to Android updates.

With my own experience of contacting Motorola about software updates for the XT1068 I discovered that their Customer Service department can’t communicate with their Software Update department and vice versa, for some strange reason. At one point the service representative was trying to help me with obtaining software update information for the XT1068 via the IMEI number but couldn’t because of the communication issue mentioned above. Seemed as though at times the responses were very robotic in nature as though I wasn’t communicating with a real human.

Currently the Moto G 2nd Gen hasn’t received the Android 5.1 update yet. It is the only Moto series smartphone (apart from Moto G 2nd Gen with 4G) to not receive the update. Below is a list of Moto smartphones where the update is either available or is currently being rolled out:



Some users are fed up with Motorola not sorting out the critical app management and memory leak issues (there are no workarounds) for the Moto G 2nd Gen. Has been mentioned on the Motorola Community forums. In fact there is a hot thread which is in the top ten that covers this issue, which Motorola aren’t taking seriously and the maintenance release doesn’t fix the issue. Many users find that the Moto G 2nd Gen on Android 5.0.2 is unusable.

Upon close research of the issue it was found that Motorola caused the issues (it isn’t an Android one) by fiddling around with a setting called minfree, which they shouldn’t have messed around with. As the old saying goes, If it ain’t broke don’t fix it!. Android 5.1 properly fixes the issues for the Moto G 2nd Gen which Motorola have yet to make available. Motorola MUST provide the Android 5.1 update for the Moto G 2nd Gen.

Android 5.1 (released on 9th March 2015) introduces dual SIM support. The New Zealand version of the Moto G 2nd Gen (XT1068) can take 2 SIM cards. Motorola’s software for handling dual SIMs is unofficial (not supported by Android). It is astonishing that the Moto G 1st Gen with 4G (the variant with dual SIMs) has an update available to Android 5.1 before the Moto G 2nd Gen (XT1068). Where are your software update priorities Motorola?

To make matters worse (by putting the boot into Moto G 2nd gen users) Motorola have made the very embarrasing move of updating the Moto E (1st and 2nd Gen) a budget smartphone to Android 5.1 before the Moto G 2nd Gen which is a mid range smartphone. Absolutely appalling behavior by Motorola which is unacceptable. Once again this shows that Motorola don’t have their software update priorities sorted. A manufacturer should NEVER make software updates a higher priority for a budget level device over a mid range one. There may be light at the end of the tunnel with Android 5.1 currently undergoing testing on the Moto G 2nd Gen.

New Zealand consumer laws are not recognised by Motorola. In the warranty document for the Moto G 2nd Gen (XT1068) no New Zealand consumer law is mentioned and a limited warranty is applied to New Zealand, when in fact a full warranty applies (24 months) under the CGA (Consumer Guarantees Act. Samsung is a good example of a manufacturer that correctly mentions the New Zealand consumer laws and the correct warranty period (24 months) for their smartphones.

Considering the fact that the Moto G 2nd Gen is unusable with the software causing critical memory leaks and improper SIM support etc, Motorola have failed to comply with section 6 (goods are of acceptable quality) of the CGA. Motorola can easily meet their obligations under the CGA by providing an Android 5.1 update for the Moto G 2nd Gen.

An ultimatum will be given to Motorola which will be that their head of the Software Update department responds to the blog post within 2 days (reasonable timeframe), with the following requirements being met:

  • An in depth explanation as to why the Moto G 2nd Gen hasn’t received the Android 5.1 update yet
  • Explanation as to why Moto G 2nd Gen users have been treated very badly compared to other Moto users when it comes to software updates and customer support in general
  • What Motorola WILL do to ensure that the Android 5.1 update arrives for the Moto G 2nd Gen before the Android 6.0 update is rolled out to selected smartphones
  • Steps that Motorola will take to ensure that a lower level device doesn’t receive a software update before a higher level device in the future
  • How Motorola will improve its communication with its customers

If Motorola fails to respond properly in a timely manner then the Moto G 2nd Gen Android 5.1 update issue WILL be escalated. Some possible options to take as part of the escalation include coverage of the issue on Fair Go (screens on public TV nationwide and internationally) and the Disputes Tribunal.

01 April 2014

JavaME 8 SDK Supports Linux

Have received some excellent news regarding JavaME 8 Embedded support for Linux. In previous versions of JavaME support for Linux was dropped for the SDK with no particular reason given as to why. Now support for Linux is coming starting with the JavaME 8 SDK, which will likely arrive in around 3 months time. Typical policy with release dates on Oracle products and services is that no specific release dates can be given. The SDK could take much longer to arrive than expected.

In the JavaME 8 SDK for Linux two emulators will be included for developing/testing embedded programs. One for Raspberry Pi and the other for the Beaglebone Black. Sharp eyed readers may have spotted the new support for the Beaglebone Black that has been a long time coming. While the Raspberry Pi is OK for basic embedded projects there are many projects that require more comprehensive hardware, which the Raspberry Pi lacks (eg reasonable number of GPIO pins, advanced power management support, internal storage).

Coincidentally at around the same time important announcements are being made by the Beaglebone Foundation on programming language support for the Beaglebone Black. JavaScript support will be dropped in favour of Python and Java. This has been a long time coming since many developers were very unhappy with the current language support. Especially for a language like JavaScript which only works effectively for Web Applications. Many developers were already doing projects written in Python instead of JavaScript which placed the foundation in a very embarrassing position.

For some time the foundation has been going against the needs of developers by forcing them to create programs using JavaScript that has a dependency on the Internet. Many developers found this unacceptable since most of the projects they were developing needed to be fast, run for long periods of time, and have good low level hardware support. The announcement can't come soon enough since many of the developers were switching to the Raspberry Pi even though it wasn't the best solution for their embedded projects.

Can't wait to see what can be created using the Beaglebone Black, and JavaME 8 Embedded. Looking forward to creating a basic weather station as my first venture into embedded development. For those that are too impatient to wait the the stable JavaME 8 SDK to arrive (with Linux support) there is a preview version coming that will arrive in a few weeks, so hold tight a while longer.

23 January 2014

Linux Mint Switch

Been using Ubuntu for over a decade, however Canonical have made some controversial decisions that have caused me to seriously look at making the switch to an alternative Linux distribution. Canonical started making some of these bad decisions with Ubuntu 12.04. Unity had made its debut and I was prepared to give it a fair spin before passing judgement. Many Ubuntu users greatly disliked Unity with a vengeance.

After using Unity for at least a month I had experienced many of the problems that users experienced. For starters it was very difficult and time consuming to launch programs through a dizzying array of filters that had to be applied, otherwise every program would be shown, or not at all. One essential requirement for a desktop is to allow some customisation to suit a users needs. Customising Unity wasn't possible in any shape or form. No program was provided to do this.

What really provided grief was the Houdini global menu system that every installed program had to support, provided it had menus. If a window had a menu bar then the menus would be hidden at the very top. You would need to be aware that the program provides menus. Also accessing a menu is an exercise in frustration with ensuring the mouse pointer is in exactly the right place to make the menu bar appear.

To make matters worse the performance of Unity was downright sluggish (eg too much CPU used when moving a window, slow to startup), and windows would be garbled in a multi-monitor setup with some computers. Programs couldn't be made to show full screen. On one computer Unity would crash regularly. Unity certainly wasn't what I would call a production ready desktop with its major usability, stability and performance problems.

Not everything about Unity was a bad experience. Liked having a bar where you could quickly and easily see/select running programs by their icon, which is much nicer than the traditional taskbar approach when you have many programs running. Easy to logout, shutdown etc from the same place as in previous versions of Ubuntu. Unity is very aesthetically pleasing to look at, which looks as though it has been done by professional Graphics Designers.

Currently I have been using Gnome Shell (version 3.4) as a replacement to Unity which is working out well for me despite having to install some extensions to sort out all the major issues. The performance, stability, and the sane UI (User Interface) of Gnome Shell have been exactly what I was after but didn't get with Unity. To top it all off Gnome Shell has a professional/sleek look about it. Unfortunately the recent versions of Gnome Shell have made a habit of removing useful features, and have stuffed up existing ones making the UI volatile. The program launcher is a good example of this.

Had the experience of trying out the Cinnamon desktop with Linux Mint (version 13). So far I have been impressed with the fact that the desktop brings out the best of the old and new desktops in a way that makes it modern without being slow, difficult to use, and unstable. Although Cinnamon has its own issues just like any other desktop it is improving at a good pace without providing a Faulty Tower UI. Looking forward to the next set of improvements made with Cinnamon.

Canonical's recent efforts to focus on the mobile side with Ubuntu Touch, and rolling out their own unproven technologies which duplicates existing ones has given great cause for concern. There is a lack of focus on the desktop side for Ubuntu as can be seen with Unity and Mir as examples. While I realise that the GUI system (X Windows) needs an overhaul there is already a replacement that is getting close to being production ready (Wayland). Mir was created by Canonical out of a disagreement with what Wayland was doing. Very ironic that Mir is essentially doing many things the same way/similar as Wayland, what a wasted effort! Compatibility of existing/legacy programs remains up in the air with Mir. No wonder users are leaving Ubuntu in droves.

If Canonical continue to ignore their customers then more of them will switch to alternatives. Seriously pondering making the switch to Linux Mint (version 17) in order to get a sane UI that is production ready (fast and stable). With the way things are going with Ubuntu I don't have much confidence that Canonical will dramatically turn things around in time for Ubuntu 14.04.

01 November 2012

Oracle Certified Associate, Java SE 7, Programmer Study Guide Review

This book review covers Oracle Certified Associate, Java SE 7, Programmer Study Guide (ebook version) from Packt Publishing, which was recently published. Inside the book you will find it covers general topics for the Oracle Certified Associate certification, and provides sample questions in all chapters that one might find in the exam.

Some of the topics that the book covers include the following:

  • Java data types
  • Decision constructs
  • Classes
  • Handling exceptions
  • Arrays and collections


Excellent explanations are provided on the topics the book covers. Especially on memory management which is a key area to understand about the Java language. Most other books don't provide the same level of explanation on this topic as this book does. Plenty of good advise is provided on handling exceptions in a Java application. All key Java 7 features are covered in reasonably good detail.

What is highly unusual about this book is that it aims to be more than just a certification guide by also acting as a general reference. Unfortunately that aim is not reached since some language basics are not covered, which include using Generics and the other key collection classes (HashMap, HashSet etc).

Highly recommend this book if you are going for the certification since it provides good coverage of the topics that are covered, and a decent number of questions for each topic that test what is learned. However this book falls a bit short on covering all the Java language basics that one would expect from a general reference.