Healthy Code Magazine - May 2014 Issue

From the Editor

Greetings!

Welcome to the May 2014 issue of Healthy Code magazine. In this issue we serve you functional programming, DSLs, Android coding and much more.

Venkat Subramaniam continues to enthrall by taking us a step forward from his last month’s article ‘Learn to Learn’. He leads us to the territory of Functional Programming with the newborn Java 8.

If you have been dabbling in Android applications, you can read Pranay’s article on building a Movie Review application (Code Less Do More) in Android. In his article he simply shows us how to build this whole application from existing libraries that are available freely without writing much code. Then, we have our myth busters(!),

about how creating index in Oracle doesn’t really improve the performance. Plus, Siddharta is back with Python and talks about creating DSLs this time. Healthy Code interviewed Shyamala, UX designer at Amazon about the future of Android design and she has some interesting things to say. What do mobile applications have in store for developers?

Rinish, CTO of RapidValue Solutions shares his insights for you to read. We are bent upon delivering technically focussed articles. And that’s why your comments are most important. Keep writing to us at feedback@healthycodemagazine.com. Enjoy reading!!!

Code Less, Do More

Let’s build great Android apps with other’s code

“I believe Android will be stronger in the developing world than it is in the developed world.”

– Fred Wilson

PranayAiran

Thousands of Android applications are being built everyday. With a significant number of Android developers out there, a large volume of code is being churned day in, day out. I can say for sure that someone has already created much of the code our developers write. This ‘already-created-code’ has also been modularized as libraries and open sourced for others to use in their applications. So, why reinvent the wheel?

Isn’t it possible to develop a real time Android application by using these libraries? Can’t we just reuse the code and tweak it a bit and build a complete application? Sure, we can, and I’m just going to do that. In this article, we’ll see how we can leverage various libraries that are available to rapidly develop an Android application. Let’s build an awesome movie review application with as less coding as possible.

The Premise:

We love movies and a lot us are movie buffs. Whenever a new movie is released or we want to watch a movie, we check its ratings first. Most of the times, the moviewatching decision is based on how others feel about the movie, right?

But every time you want to watch a movie, you don’t want to open your laptop to find the ratings, the cast and other details. Wouldn’t it be awesome if we can have a mobile app that can help us decide what to watch? How about an app having an option to search any movie from 2014 to 1950?

Sounds interesting, right? Figure 1.0 shows how our application will look when it’s ready.

Let’s see how we can go about building this application. We need a Movie rating API to start with. We love IMDB, but IMDB does not have any official API. For our app, let’s use the API from Rotten Tomatoes. Then, we will use several Android concepts such as Action Bar, Drawer, Asynchronous Data Loading, listview, etc., and libraries like ActionBarCompat, Retrofit, Picasso, Pull-to-Refresh, NavigationDrawer, and Card UI. While I don’t have enough space in the magazine for showing you how to use all these libraries, this article will focus mainly on ActionBarCompat, RetroFit, Picasso, Pull-to-Refresh and Card UI libraries.

Let’s use Eclipse IDE for building the application. Launch the Eclipse IDE in your ADT bundle. Create an

ActionBarCompat

ActionBarCompat is used to add action bars. It is similar to the ActionBarSherlock library but provided by Google and included in the new support library. ActionBarCompat library is backward compatible with all Android versions and Google recommends it as well. You have to import the support library v7 into your workspace to work with ActionBarCompat. And here’s how you do that.

Click on File->Import->Android and choose Existing Android Code into workspace option.

Locate your Android SDK folder and go to sdk/ extras/android/support/v7/appcompat. Import

Android Application project called MoviesTomatoes. See if you can get your MoviesTomatoes app running in emulator or phone.

Figure 1.0.The application that we plan to build.

this project in your workspace. Note: If v7 library shows error you need to change the Android version

Right click on your MoviesTomatoes project, go to properties, and add the v7 project as library dependency in Library section.

We can now add the action bar to our application by configuring the action bar theme in our AndroidManifest.xml file.

android:theme=”@style/Theme.AppCompat.Light. DarkActionBar”

Go to MainActivity.java and make your class extend ActionBarActivity.

import android.support.v7.app.ActionBarAc tivity;

public class MainActivity extends Action BarActivity { ... }

Figure 2.0 shows how our application MoviesTomatoes will look like once the action bar is added.

The complete code for integrating ActionBar Compat can be found at https://github.com/ pranayairan/CodeLessDoMore/tree/master/ CodeLessDoMoreHelloActionBar.

Consuming the Rotten Tomatoes Service

As we’re going to use the Rotten Tomatoes API to get the movie ratings and other information, we need to register with Rotten Tomatoes and create an API key. We’ll use this API key whenever we send requests to their service.

You can go to http://developer.rottentomatoes.com/ member/register and create an account. Note: Select Mobile Application in the application type checkbox provided, and enter http://www.google.com in the application URL textbox

You will get your API key after the registration. I have my key 9mxxxxx that you’ll notice being used in the application. Keep your API key handy, as we will use it to call the API.

Rotten Tomatoes is a RESTful service that returns JSON response. I would strongly encourage you to read about REST and JSON, if you are not aware of these. Now, I’m going to show you a couple of ways of accessing the API.

in box office here’s the URL: http://api.rottentomatoes.com/api/public/v1.0/ lists/movies/box_office.json?limit=10&country=us &apikey=9mXXXXXX

to access the details of a movie, you can use the following URL: http://api.rottentomatoes.com/api/public/v1.0/ movies/770672122.json?apikey=9mXXXXXX

Let’s consume these URLs in our application and display the returned data.

We can display the list of movies running in box office in a listview. If you don’t know about listview you can read more about it at http://www.mkyong.com/ android/android-listview-example/

Retrofit:

In Android applications, you can create your own thread by using classes like AsyncTask. But

2.0 MoviesTomatoes app with action bar

AsyncTask comes with its own set of problems. it.

same time, they run sequentially with each one depending on the previous one to finish before running. This makes your application slow.

We can avoid these problems by using Retrofit. Retrofit is an excellent networking library from Square, which helps us perform concurrent network calls and parse the results and map them to a Java Class at the same time. You can download Retrofit from http://square.github.io/retrofit/. You can include Retrofit jars to the libs folder of your project. Please note that the GSON library needs to be added to the build path to work with Retrofit. As we’re going to fetch data from Rotten Tomatoes we have to add the Internet permission in the AndroidManifest.xml file. <uses-permission android:name=”android.per mission.INTERNET”/>

Retrofit serializes JSON data to Java objects. In our application, let’s create the POJO for mapping JSON data that displays the movie list. We can use online JSON to Java generation sites like http://jsongen. byingtondesign.com/, http://www.jsonschema2pojo. org/ etc., for this purpose. Let’s generate a POJO BoxOfficeMovies. You’ll need to include the generated POJO in the project.

In MainActivity.java, let’s connect to Rotten Tomatoes Service and get the list of movies using the BoxOfficeMovies POJO we created. To do this let’s create an interface BoxOfficeRunningMovie, and map this interface to the Rotten Tomatoes URL.

public class MainActivity extends ActionBarAc tivity{ interface { @GET(“/api/public/v1.0/lists/movies/box_ )

(@Query( ) String limit,

@Query( ) String country, @Query( ) String apikey, } }

}

The moviesList() method accepts four arguments with the first three arguments annotated with @Query annotation. The three @Query arguments map to the three query string arguments in the URL. http://api.rottentomatoes.com/api/public/v1.0/lists/ movies/box_office.json?limit=16&country=us&apike y=9mXXXXX

The fourth parameter is a Retrofit callback that will be called when the response is received.

Let’s consume this interface now by creating a RestAdapter. The RestAdapter will create an instance of the BoxOfficeRunningMovie interface. We can invoke the moviesList() method to get the list of all movies.

public class MainActivity extends ActionBarAc tivity { onCreate(Bundle savedInstan ceState){ new er.Builder().setEndpoint build restAdapter.create class

response) { int

getMovies().

Toast.makeText(MainActivity. , “Number of movies running in Box + moviesNumber, Toast.LENGTH_LONG }

Toast.makeText(MainActivity. , “Error: “+

Toast.LENGTH_LONG }

runningMovies. ( , , }

The moviesList() method has the callback instance passed, which displays the result in a Toast for the time being. Figure 3.0 shows the output when you execute this code. That’s it!!! We have our Retrofit boilerplate code completed.

Figure 4.0. Movie item display

BoxOfficeMovieAdapter class to display the above information. While discussing Retrofit you’d have noticed that I had displayed the response from Rotten Tomatoes in a Toast. We have to replace that code to display the movie list in a list view.

= new ty. ,

(movie

The complete code for integrating Retrofit can be found at https://github.com/pranayairan/CodeLessDoMore/ tree/master/CodeLessDoMoreRetrofit.

Binding results with a listview

Let’s display the movie name, movie thumbnail image, critics rating, audience rating and MPAA rating in a list view. Each movie will be displayed in a listview as shown in Figure 4.0.

I’m not going to delve in detail into this topic. I have created an XML file for the list item, a

Figure 5.0 shows the listview of the movie application. As of now the thumbnail of the movie in our listview is not loaded as there is no way to load images directly from an URL.

You can view the complete code for listview at https:// github.com/pranayairan/CodeLessDoMore/tree/ master/CodeLessDoMoreListView.

Picasso

Let’s load the thumbnail of the movies using Picasso. In Android applications, loading images is an interesting problem. If you want to get images from a URL, you need to download the image first and then display it in image view. To make the application responsive we need to download this image in background and then load it in image view. There are lots of chances of duplication of images, so we need to

cache those as well. To implement these, we need to write many lines of boilerplate code.

Enter Picasso. Picasso is an amazing library from Square, designed to solve the image loading issue. There are lot of similar libraries like UniversalImageLoader, UrlImageViewHelper, and Volley that can be used for this purpose. You can download Picasso from http://square.github.io/ picasso/ and add it to the project.

In the BoxOfficeMovieAdapter class we have to add these two lines of code to load the movie poster image in background and display it in thumbnail.

Picasso.with(ctx).load(runningMovie.get Posters().getThumbnail())

.placeholder drawable.ic_launcher) .error drawable.ic_launcher)

.into(movieHolder.movieThumbnail

In the code above, runningMovie refers to each movie instance in the collection of movies fetched from the service.

Figure 6.0 shows the app once Picasso is integrated.

You can view the complete code of integrating Picasso at https://github.com/pranayairan/CodeLessDoMore/ tree/master/CodeLessDoMorePicasso.

Pull-to-Refresh

I want to give users a way to refresh the movie list without closing the application. We love Twitter and Facebook where we pull to get the latest tweets and posts, so why not add the same pull-to-refresh option in our movie app?

To add pull-to-refresh we will use an excellent library from Chris Banes called ActionBar PullTo Refresh. You can get the library from https://github.com/ chrisbanes/ActionBar-PullToRefresh. As we already have action bar in our application, this is the most suited library for us.

Download ActionBar PullToRefresh library from Github and import it in Eclipse. ActionBar PullToRefresh is dependent on another library, SmoothProgressBar. You can download this library from https://github.com/castorflex/Smooth ProgressBar. Note: It’s a bit difficult to build

Figure 5.0. Movies displayed in listview

Figure 6.0. Movies list after Picasso integration

these libraries using Eclipse. Include ActionBar PullToRefresh library in your movie application as a library project. We can introduce the Pull-ToRefresh feature in our app by configuring the list view inside the PullToRefreshLayout. You can do this by replacing RelativeLayout with PullToRefreshLayout in the activity_main.xml.

Card UI

Do you like the new Google Play UI? Google has introduced a nice Card UI in their applications like Google Play, Google Plus etc. We will try to create the same look and feel for our application.

xmlns:android=

android:id= >

Our listview will be inside this new PullToRefreshLayout. This wrapper will provide necessary UI for pull to refresh. Let’s create an instance of PullToRefreshLayout in MainActivity.java and set it up.

You can use Card UI libraries like https://github.com/ gabrielemariotti/cardslib but I’m going to keep things simple in our application and implement Card UI by just adding and tweaking some code. Let’s create a custom drawable with a shadow, set our list view item with this drawable and make some minor changes; and we’ll have the card look and feel.

Create a new drawable say cards.xml and add the following code that gives the card-like look and feel.

<layer-list xmlns:android= >

<item> <shape>

id.ptr_layout from( )

// Mark All Children as pullable .allChildrenArePullable()

.listener( )

// Finally commit the setup to our Pull setup

You can add the RefreshListener by implementing the onRefreshStarted() method, which has your pull-torefresh logic. In our movie application, we can call the Rotten Tomatoes web service again, get the response and create a new instance of BoxOfficeMovieAdapter class. Finally, you need to call setRefreshComplete() to indicate that the pull-to-refresh action is complete.

plete

That’s it! With this simple integration, we have a pullto-refresh functionality in our application.

Now let’s enhance the look and feel of our application using Card UI.

<padding android:top= android:right= android:bottom= android:left= />

<solid android:color= /> </shape> </item> <item> <shape> <padding android:top= android:right= android:bottom= android:left= />

<solid android:color= />

<corners android:radius= /> </shape>

</item> <item> <shape> <padding android:top= android:right= android:bottom= android:left= />

<solid android:color=

and

figure

the

between the

etc.

have

card look ready,

shows the application with enhanced

after

Navigation Drawer

Figure

Movie app with enhanced Card UI

Figure

Healthy Code

Reader:

Address: 11/6, First Floor, Fourth Street, Padmanabha Nagar, Adyar, Chennai - 600020

Scanners (P) Ltd

Dams Road, Chindadripet, Chennai -

Pranay

to

Engineer @ Intuit, developing web and mobile applications, Pranayholds a Masters degree from IIIT Bangalore. He is passionate about building mobile applications and hacking on new web technologies, and he helps Blrdroid as Assistant organizer as well. Pranay has been developing Android apps from the last 3 years and has developed a variety of apps personally and @ Intuit. He has more than seven apps in Google Play Store. He conducts workshops in colleges where he likes to share his knowledge and helps students get start with android under Blrdroid Teach Program.

You can find the code for Card UI in https://github. com/pranayairan/CodeLessDoMore/tree/master/ CodeLessDoMoreCardsUI.

You can enhance the application further by integrating Navigation Drawer and the application will look as shown in figure 8.0. The code for integrating Navigation Drawer is available at https://github. com/pranayairan/CodeLessDoMore/tree/master/ CodeLessDoMoreNavigationDrawer.

I have shared the complete code for the article in the Github repository, https://github.com/pranayairan/ CodeLessDoMore.

Seven Databases in Seven Weeks

Pragmatic BookShelf’s Seven X in Seven Weeks series is quite popular, and this is another interesting book from their stable. In spite of being two years old, it still serves as a fantastic introduction to NoSQL databases even now. Jim Wilson and Eric Redmond (also, author of, ‘Programming Google Glass’), are the authors of this book

It talks about NoSQL databases like MongoDB, CouchDB, Redis, Riak, HBase and Neo4J. The only RDBMS database that’s been discussed is Post greSQL. The choice of the databases in the book has been clearly explained in the introductory section.

Each chapter takes up one database, introduces it and tells you how to set it up. The ritualistic CRUD operations are discussed with simple code-based examples. The chapter then explores the core fea tures of the database, and winds up discussing the strengths and weaknesses. It also highlights a number of other features, which can be explored outside the book.

Apart from the regular exercises at the end of each day of discussion what’s interesting is the variety of examples covered to explain the concepts. Unlike a lot of technical books that run through a single problem in all the chapters, each database is ex talks about creating and playing with cities, Couch DB talks about music and so on.

My favorite read is the chapter on MongoDB be cause of the succinct introduction to sharding and replication concepts. ent databases, it is a treat for the experienced to un

- Prabhu Sunderaraman

Eric Redmond, Jim R. Wilson

Book Review

Building a Mobility Business

Healthy

Code spoke to Rinish KN, Chief Technology Officer of RapidValue Solutions, an end-to-end enterprise mobility services provider based out of Pleasanton, California with offices in India (Kochi and Bangalore). Rinish has previously worked as an architect at Oracle and Wipro, building e-commerce websites, before he co-founded RapidValue Solutions with Rajesh Padinjaremadam and Sirish Kosaraju in 2008. Here are the excerpts from that chat.

How did you decide to start a company that focuses on mobile technology?

In 2007, Apple came out with iPhone, and it changed the mobile phone world dramatically. All research at that time pointed out to a growing mobility and cloud market. It was then that we started RapidValue Solutions and decided to focus on mobility and build a niche for ourselves.

What was the predominant mobile technology at that time?

It was primarily the Apple iOS as that time.

Blackberry was also very popular. In those days, Apple competed with Blackberry. In the Android space, the first HTC phone was released in 2008.

What was the first opportunity that you got for your company?

First, we had to prove to ourselves that we could build mobile applications. So we hired a Java developer. There were three managers and one programmer. We built a simple expense tracking application system for iPhone and Android to prove our capability. After that, we started getting interesting projects and customers.

?

Was the learning curve pretty high for your team initially?

In India, we always have more Windows developers than Mac developers. When iOS entered the market, it was very new to all of us. However it’s not difficult to learn the platform. The developer guide of Apple is very helpful. They have very good videos, articles and documentation. Their XCode editor is awesome. We learnt most of the technical details from their developer portal. Even today we hire straight Java programmers, C++ and C# developers and train them in mobile development using the same way.

What kind of applications did you start building first?

We started building native applications initially for iPhone and Android. Native applications are the ones that you have to download from App Stores such as Apple’s iTunes or Google Play Store on your mobile before you can use them. With Native apps, users can make use of phone capabilities like Camera, GPS, offline browsing etc.

We started building business to customer (b2c) applications. A good example of this kind would be like media/publishing application, music streaming applications and retail product catalogs. These native applications interface with the server to access data from content management systems and provide you the latest information on the phone just like your client-server applications.

?

Rinish K N

What kind of applications are you developing today?

Over the last five years, we have expanded from mobile application development to providing end-to-end enterprise mobility services. Our services include mobile strategy, UX/UI design, mobile app development, enterprise system integration, mobile testing and ongoing support and maintenance.

We are now developing a lot of applications for large enterprises and many Fortune1000 companies. Some of the applications include:

HR Management Service by which employees can apply for leave, view pay slips etc.

Mobile Commerce by which consumers can view and purchase products online.

Inventory Management App for scanning at warehouses for receiving goods and managing inventory.

Physicians Communication and Scheduling App for doctors to interact with their staff.

?

Online Class Room App for University faculty to interact with students, and many more types of applications across industry segments. In many cases, we are extending the ERP systems for access from mobile devices.

In addition to mobility services, we have recently launched a global product ‘eQuipMeTM’, a mobile field service suite which connects field service technicians and customers in real-time from any mobile device.

Tell us a little bit about mobile websites. How different are they different from native applications?

The evolution of mobile websites is very similar to the evolution of web applications. Long ago,

we moved from Mainframes to Client Server Computing. With the advent of Internet and we started building web applications.

Similarly in the mobile space, you can view the native application as a client server application interacting with a server at the backend. Mobile websites are similar to web applications. You simply use the browser in the mobile phone and connect to your application on the web server. Even though any website can be viewed from the mobile browser, you need to build a mobile website to leverage the features of the mobile phone and for proper rendering.

However, now a days many are building websites with responsive design. Responsive websites are a notch better than mobile websites. There are so

many types of phones in different sizes and shapes available today. So your mobile web application should adjust to the multiple phone sizes and platforms. A responsive website will do that for you.

If the requirement is to reach out to a large number of users as in mobile commerce application, mobile website is the best option, and if rich user experience and phone capabilities need to be enabled for the mobile app, native app development is the right approach. Another option is the Hybrid Mobile Web App which has some capabilities of mobile website and some of native app.

What are Hybrid applications?

Hybrid applications are a mix of native and other types. The UI is built with HTML 5 and JavaScript. The same JavaScript is used for accessing native features of the phone like Camera, Gyroscope, etc.

You use technologies like PhoneGap, Titanium Appcelarator or RhoMobile to achieve this. These frameworks take care of the native code that is needed to run your application across different platforms like iPhone and Android.

There are so many Mobile JavaScript frameworks like jQuery mobile, Sencha Touch, Kendo, etc. How does a developer navigate this JavaScript land?

It is better for a developer to have multiple skills. They should pick up HTML 5, JavaScript, iOS or Android to begin with. There are many JavaScript frameworks, but once you pick one up, you should be able to switch to others. Just like if you know Java, you can easily learn to program in Servlets, JSP, Hibernate and Struts. It’s similar to that.

Sencha Touch is very rich in UI. jQuery Mobile is very light-weight. All these frameworks have their own advantages and once you know any one of these frameworks, the switch is not very hard.

There is a perception that mobile application projects are short term (3-4 months). How do you sustain development

through the year?

Yes. Mobile development is a fast-paced business. We typically deliver a full application in 3 months on average. But in most cases, we continue the client relationship for 2 to 3 years, either in the same project or other projects. So, sustaining development team is not an issue for us.

Is it possible to build a large-sized company with prime focus on mobile development?

Absolutely. The enterprise mobile application space is rapidly growing. The company budgets for building mobile applications are increasing every year. RapidValue currently has over 200 employees. Given that we have expanded rapidly in the past five years (employees, offices and customers), we are expecting 100% Y-o-Y growth. We strongly believe we can do it!

What are your thoughts on wearable devices and Google Glass etc.?

It certainly looks like the future. Previously, we never thought our phones would connect to the Internet. Now we do it every day. Cars are getting connected to the Internet in the US. Google Glass is another good example. Wearable devices and connected devices is where RapidValue will focus in the coming years.

Now that mobile technology has so many job opportunities, where does a developer stand in the mobile space?

Actually mobile development is quite similar to Java development. People who have knowledge in Java or C# can get into mobile development. For a Java developer, learning Android is similar to learning Spring or Hibernate Framework. Anyone having knowledge in object oriented programming can start on mobile application development.

Passion for learning is the key.

One of the frequently encountered solutions that application developers are offered, while dealing with performance issues with the oracle database is: “create an index on that column”. This may enhance the performance in some cases if you know your index well enough. However this can actually degrade or not have any significant impact on the SQL performance in the application at all. Therefore it’s important to be aware of the behavior of index if you want to leverage its true potential. We have identified a bunch of issues while working with index in Oracle and discussed them in this article.

Here’s a list of concerns raised by developers and our response to them.

Ankit Kumar Katiyar & N.S.Sekar

Concern #1:

I have created an appropriate index on particular column. But why is the query engine not picking up the index?

This may happen due to bad or incomplete statistics. In the absence of statistics, the optimizer (Cost based optimization) may choose a full table scan (FTS) as compared to indexed access.

Recommendations:

Prior to testing queries, just make sure you re-analyze the table and index with dbms_stats. This provides the optimizer with good metadata.

You can use the following queries to check the last analyzed status.

FASTER ACCESS

You can use the following queries to execute the dms_ stats procedure to analyze objects.

Concern #2:

I have created an appropriate index on a particular column and I have also verified the earlier step discussed in Concern#1. I still see that oracle is not using that index.

This may happen if the number of rows in that table is less or your query is returning almost all the data in a table.

Recommendations:

If table is small that it can be read in a single I/O call, then a full table scan of table might be cheaper than an index range scan. Single I/O call can be defined by

DB_FILE_MULTIBLOCK_READ_COUNT parameter and value defined by blocks.

If your query is returning the majority of the data in a table, then a full table scan is probably going to be the most efficient way to access the table and optimizer may choose to decide that it would be more efficient not to use the index.

Concern #3:

I have created proper B-Tree Index on the particular column and have also analyzed the table and index. I still don’t find oracle using that index.

Oracle B-TREE Indexes can surely help in improving the query performance provided there is optimal selectivity on that column. The ratio of the number of distinct values in the indexed column/columns to the number of records in the table represents the selectivity of an index. Ideal selectivity is 1 in case of primary key and unique key.

While optimizing, oracle takes a decision of choosing an index based on I/O. As discussed earlier, if the query is returning the majority of the data in a table, then a full table scan is probably going to be the most efficient way to access the table.

Recommendations:

We should create indexes on tables that are often queried for less than 15% of the table’s rows. This value may be higher in situations where all data can be retrieved from an index, or where the indexed columns can be used for joining to other tables.

Please check if you have right index on that column. In other words, in oracle while standard B-tree indexes are most effective for columns containing a high number of different values (good selectivity), bitmapped indexes are most appropriate for columns with a limited number (poor selectivity) of possible values.

In general, B-tree indices are good for OLTP and Bitmapped indices are good for OLAP systems. Factor in your usage, prior to creating the index.

Concern #4:

I have a query

The query engine is still not using the index.

If you are using the SQL “like” clause then it can be tricky because the wildcard “%” operator can invalidate the index.

Recommendations:

STRING% will do INDEX RANGE SCAN data because optimizer knows where the string gets started.

% STRING will do the INDEX FULL table because LIKE expression that starts with a wildcard.

%STRING% will perform the FULL table scan because optimizer doesn’t know from which letter the String get started.

Concern #5:

I have a query, I also have a proper index on id column. Why is the query engine still not using the index?

If you have got a WHERE clause which contains something like “id is null” then query engine will always perform the full-table scan because NULL values cannot be indexed. If you have no choice, but to have this condition in your query, consider replacing it with a NVL function.

Recommendations:

If you have a null in your where clause you may have to keep the following in mind:

When you have “IS NOT NULL” type WHERE clause will use an index

When you have “IS NULL” type WHERE doesn’t use an index

Concern #6:

I have a query, I have proper index on name column then why is the query engine not utilizing an index?

Even though the name column has an index, the upper functions will invalidate the index and WHERE clause predicates might invoke FTS (unnecessary I/O).

Recommendations:

In such cases, use Function-Based index on that column. Function-Based indexes give the ability to index computed columns and use theses indexes in a query as shown here.

operator, the index for that column is disabled.

Recommendations:

You can rewrite the above-mentioned query as

Concern #10:

I have following query

Concern #7:

I have created a Function-based index on a table column, yet when I check my execution plan, the optimizer ignores the Function-based index?

Typically, function-based indexes or any index are ignored when analyze the index has not been performed.

Recommendations:

After creating a function-based index, don’t forget to re-gather table statistics and get extended statistics on the function.

Concern #8:

I have a query,

I have a proper index on these columns but no use of the index.

This may happen if you are performing mathematical operations on the indexed column then oracle will invalidate the index and will go for the full table scan.

Concern #9:

I have a following query

In this case name column is indexed but oracle is not using an index. Why?

When an indexed column appears on both sides of an

Inspite of having a proper index on these columns why doesn’t oracle use it?

If we use the NOT EXISTS then nested index scans will be used in the sub query for each row in the DEPARTMENT table. The only records that will be returned from DEPARTMENT are those that return no rows from the sub query, and no full table scans are performed by the sub query.

Recommendations:

The following query statement is more efficient. department.department_id=employee. department_id)

Concern #11:

In my query, I have an index on a DATE column but oracle is not using index if I fetch results using JDBC driver?

This might happen due to data type conversion between Date and TimeStamp. Developers, typically use the setTimestamp method in order to set time. When this is done, the index on the DATE column will not be used. This is because, oracle internally converts/casts datatypes (of date to timestamp) .

Recommendations:

You can address this problem with the following:

Concern #12:

In spite of having index on “first_name” and “last_ name” columns the query “

takes much longer than expected.

The use of ‘OR’ statements confuses the optimizer (Cost Based Optimizer). It will rarely choose to use an index on column referenced using an OR statement.

Recommendations:

You can work around this issue by using UNION ALL as shown here.

creating a composite index on columns that are frequently used together in WHERE clause conditions combined with AND operators, especially if their combined selectivity is better than the selectivity of either column individually. Even If you do not include the first column of a concatenated index in the WHERE clause of your statement then also Index Skip Scanning will be used.

Summary

This article was just a brief overview at database indexing with some light on b-tree index, bitmap indexes, function-based indexes, and composite indexes. Index efficiency is hard and finding appropriate index even harder. We hope that these tips when used appropriately may help you debug performance issues, even after you have created the index on the relevant columns.

Concern #13:

I have created composite index on the column but how does it work with my query?

A composite index contains more than one key column. Composite indexes can provide additional advantages over single column indexes. Consider

In general, when things are really slow due to a SQL statement, in your application, use the EXPLAIN PLAN to look at the execution plan of the statement. Following this, make the changes in your SQL based on cost estimation.

Remember that “FULL TABLE SCANS ARE NOT ALWAYS BAD” and “SQL INDEX != FASTER ACCESS” in all scenarios.

Happy indexing!!!

Sekar is Vice President of Engineering at Success Factors. He has previously worked as Director at Yahoo and Informatica. He is a seasoned tech nology and product development executive with experience in building and scaling distributed en gineering and product teams from multiple ear ly-stage startups to the next level. His expertise includes Data Integration, Data Quality, Web Ana lytics, Internet Platforms, and SaaS

Ankit Kumar is currently serving Successfactors (SAP Cloud) as a Principal Engineer. His work is with the Employee Central (EC) product wherein his main focus is to make EC world’s most highperforming, scalable, and blazing fast cloud platform. Prior to this, he worked with Oracle as a technology lead and Hewlett Packard (HP) as a software analyst. He holds a patent and disclosure in database and network technologies, respectively.

NS Sekar

Ankit Kumar

Technology Conferences

Regional Scrum Gathering India

July 11, 12 - Hyderabad

With the theme of “Humane Scrum”, the Region al Scrum Gathering® India 2014 focuses on explor ing techniques, tools, behaviors, and experiences that help bring about the mind-set so essential to tions small and large.

Venue: Hotel Trident, HITEC City, Near Cyber Towers, Madhapur, Hyderabad, AP 500 081. http://scrumgatheringindia.in/

JULY 19, 2014

Rootconf 2014

May 16-17, 2014, Bangalore

Rootconf is a conference that will help you plan and develop a strategy map for infrastructure and devops. It will show you the building blocks for reaching a strategy for Continuous Integra tion, Deployment and Delivery.

Target audience: Organizations who need a CI developer teams and performance of their web stacks.

Venue:

MLR Convention Centre, J.P. Nagar Brigade Millennium Complex, J.P. Nagar 7th Phase Bangalore, Karnataka India. Website:

tiConf India will be a single day event featuring some of the best Titanium de velopers and evangelists from around the globe. We will be talking everything about Titanium, Mobile Development, Cloud and JavaScript.

Venue:

25 Windsor Square, Golf Course Road Bangaluru 560 052 Karnataka, India Website: http://ticonf.org/

Our combined customer discovery and agile product development won’t just get you to an MVP: It will provide your team with the hands-on training to set up and to run effective experiments long after the engagement ends.

Phase 1: Getting Started + Product Discovery Phase

Accelerating Discovery + Introducing Agile Development Phase

Transition and Closeout

Each backed by more than a decade of experience, our agile consultants and coaches work with managers and teams to address people, process and products for a more comprehensive approach.

Lean + Agile Assessment

Agile Management Consulting

Agile Team Coaching Lean Product Innovation

the art of continuous improvement

Great teams build great products. Achieve a state of continuous team improvement with Sensei, a simple retrospective tool for agile teams.

Try it for free, no obligations:

SenseiTool.com

Get the real-world insight, practical advice and experience needed to lead your team, speed time to market, and boost morale. We offer classes for all levels, including:

Agile Engineering Agile Testing Workshop Scrum Product Owner Training ScrumMaster Training Organizational Intro to Agile

www.lithespeed.com

703.745.9125

@lithespeed

Domain Specific Languages in Python

An interface should be designed in such a way that the code, which a programmer writes, is almost same as what he or she is thinking in their head. Such an interface is termed as natural. With a natural interface, there is less translation to do when converting from the mental model to the actual code itself. This is beneficial not only when writing code, but it is also easier to understand the intent when reading the code later on.

One way to create an interface that is as natural as possible is via Domain Specific Languages (DSL).

Domain Specific Languages

Generally speaking, we use a general purpose programming language to get our job done. However, because they are a general purpose, we may sometimes have to go through unnatural hoops to get things done. Let us take a simple example of pattern matching.

Suppose we want to determine if a given string represents an IP address. The process of doing so might involve taking the string, splitting it up on the period, and then checking if there are exactly 4 parts, and whether each part is a number between 0 to 255. A Python implementation might look like this: (ip_address): components = ip_address_string.split( ) if len(components) != 4: False : int_components = [int(component) for component in components] except : False for component in int_components: if component < or component > : False True

To someone looking at the code for the first time, it is not obvious what pattern this code is matching. Also, if we want to change the pattern that is being matched, then it isn’t straightforward to make the change.

Using regular expressions, we can change the code to something like this: def is_ip(ip_address_string): match = re.match( ,ip_address_string)

Siddharta Govindaraj

if not match: return False for component in match.groups(): if int(component) > : return False return True

In regular expression notation, the string “^(d{1,3}). (d{1,3}).(d{1,3}).(d{1,3})$” amounts to matching 4 groups of digits, each group having 1-3 digits, separated by periods.

Anyone can look at the regular expression and understand the pattern that is being matched. If we need to make a change to the pattern, then it is easy to plug in the new pattern in the code.

Regular expressions are an example of a domain specific language. It is a language that allows us to express the pattern, rather than an implementation on how to match the pattern. We are thinking in our head, “I need to match four integers separated by a period,” and the regular expression allows us to put that directly into the code. Without regular expressions, we need to do a lot more work in translating our mental model into the code when writing it, or understanding the intent when reading the code, leading to unintuitive or difficult to understand code.

There are many other DSLs that we use daily without even realising it. For example, SQL is a domain specific language for retrieving data from a relational data source. By using SQL we can communicate very clearly about what data we want to retrieve rather than specifying how the data should be retrieved.

Now that, I have opened the doors of DSL, let’s walk through the features of DSLs.

External v/s Internal DSL

There are two types of DSLs: External and Internal In an external DSL, a special syntax is used as a language. This syntax is specified as a string or in an external file. The regular expression interface that we saw above is an example of an external DSL.

Internal DSLs don’t use an external syntax. Instead, they make use of the syntactical features of the programming language cleverly to make the interface more natural.

Let’s discuss this External and Internal DSLs with an example. To begin with, let us decide the public API that we are going to use to make the calculations.

There are two ways we can design the interface for the calculator.

Internal DSL: Provide classes that we use to create the expression that we want to evaluate.

External DSL: Use an expression syntax, which we must parse and evaluate.

Calculator: Internal DSL way

The code snippet for the Calculator using the Internal DSL approach looks like this.

Add( , Mul(2, 3 , 6)).evaluate() , Add(3, 4)), ).evaluate()

We build up the expression using normal python classes like Add, Div and Mul, which are evaluated to give the result.

Implementing the Internal DSL syntax as shown above is an interesting premise in Python.

Let us start with the Add class. Add should be able to take any number of parameters in the constructor, and return the sum when the evaluate method is called.

import operator

from functools import reduce class Add( ): def __init__(self self.terms = args

evaluate(self): return reduce(operator.add, self.terms)

This simple implementation handles adding a series of constants:

Add( , 3).evaluate()

Add(2, 4).evaluate()

But, the Add class should also be able to take other expressions as a parameter. Add(1, Add(2, 3)) should

The words ‘static’ and ‘synchronized’ are a menace to Test Driven Development.

Continuing to use a miserable developer tool is like being complacent in an abusive relationship -- why not get out for a better life?

Pragmatic Programmer Quotes

also return 6. Our current implementation will give an error because in the evaluate method we assume all the terms are numbers.

There are two ways to handle this. One way is to check for expressions and call evaluate on the subexpression before adding. Such an implementation will look like this: (self): total = for term in self.terms: if isinstance(term, Add): total += term.evaluate() : total += term total

The other option is to create a Number class with an evaluate method. A number will always evaluate to this example.

( ): (self, value): self.value = value (self): self.value

With this class in place, we can modify the Add class to evaluate each expression before adding the values.

( ): (self): reduce(operator.add, [term evaluate() for term in self.terms])

Now we can add both numbers and sub-expressions. When evaluate is called on a term, it will return the number or evaluate a sub-expression, depending on which object it is. Unfortunately, this change means that we have to wrap numbers in the Number class and we have to now invoke the Add class like this

>>> Add(Number( ), Number(2)).evaluate()

>>> Add(Number( ), Add(Number(2), Number(3))). evaluate()

6

and Div.

( ): (self self.terms = args (self): reduce(operator.sub, [term. evaluate() for term in self.terms])

( ): (self self.terms = args (self):

reduce(operator.mul, [term. evaluate() for term in self.terms])

( ): (self self.terms = args (self): reduce(operator.truediv, [term. evaluate() for term in self.terms])

With these classes in place, we can now start mixing operators.

>>> Add(Number( ), Mul(Number(2), Number(3)), ), Number(6)))

Okay, now that the basic functionality is working, let us clean it up a bit. First, there is that annoying need to wrap up numbers in the Number class, which makes the interface quite ugly and verbose. Second, there is a fair bit of duplication between the various classes.

it accepts numbers and internally wraps them in the Number class.

import

( ): (self self.terms = [self.wrap_term(term) for term in args]

(self, term): Number(term) if isinstance(term, term

This syntax looks ugly, but we’ll get back to that problem later. For now, we have support for subexpressions. Let’s go ahead and implement Sub, Mul

To clean up the duplication, we create a base Operation class and put all the common functionality in there. After the change, the code looks like this:

External DSL Internal DSL

Can use the most natural syntax Syntax limited by syntax of programming language Easy to understand the intent Easy, but less than an external DSL

Can be maintained by non-programmers Cannot be maintained by non-programmers Requires that you implement parsing logic No parsing required

Operation( ): (self self.terms = [self.wrap_term(term) for term in args] (self, term):

Number(term) if isinstance(term, term (self): reduce(self.operation, [term. evaluate() for term in self.terms])

(Operation): operation = operator.add (Operation): operation = operator.sub (Operation): operation = operator.mul (Operation): operation = operator.truediv

We can now use the module in a more natural way!

>>> Add( , Mul(2, 3 , 6)).evaluate()

, Add(3, 4)), ).evaluate()

>>> Add( , 3)).evaluate()

Calculator: External DSL way calculator.evaluate(“ + 2 3 + / 6 ) calculator.evaluate(“ 3 + 4 ) / )

In the External DSL approach, we pass the input as a parse and evaluate. We will reserve the external DSL implementation for later article.

External and Internal DSLs.

In short, if the main users for your package are going to be other developers (for example, if you are creating a module that will be used like a library with other modules), then it is worthwhile to see if the language contains a natural syntax that you could adapt into an Internal DSL. Otherwise, go for an external DSL interface.

The complete code of the article can be downloaded from 2014

Siddharta Govindaraj is the founder of Silver Stripe Software, a product company based in Chennai. He is active in the Chennai tech, agile and entrepreneur communities in his free time.

Siddharta

The Joy of Functional Programming

More than which language we pro in it. Almost every mainstream pro of syntax. In languages, as in love, we have to see beyond the looks very quickly. In this article, we will discuss

semantics of what we express. We will also look at the key reasons to use this style of programming and how we

The Power of Expression

If we ask a fellow programmer what they under stand by programming, we may hear words like cod ing, compiling, execution, and so on. But, in essence, it’s an act of communication, a form of expression. It’s not just expressing ideas for execution by the comput ers. It’s more than that, a lot more, in fact. It’s what we create so fellow developers, and ourselves, can main tain moving forward.

Much like writing in a natural language like English, there are several ways to express ideas. Some writings are easy to grasp while others are hard to follow. Pro grams are like that, and if we’re keen, it’s not hard to

A good code should read like a story, not like a puzzle.

pick either active or passive voice. The former gives

Programming has similar styles.

What is popular or the most familiar is not necessar

Venkat Subramaniam

style is the one that most of us are familiar with, and the functional style is the one that has been around for as long, but as a well-kept secret.

Imperative v/s Functional Style

Most of us have programmed in imperative style, maybe without realizing it. It’s not our fault that we’ve been taught to code that way, and most of the languages within our reach promote that style.

Imperative style is primitive; we express our ideas in detail, telling not just what, but how to do things. At

After all, computers follow instructions, and it’s our duty to give them.

Functional style is declarative; we express our ideas at a higher level of abstraction and let the underlying ity.

Let’s get a feel for them using a few examples.

Taking Full Control

visible by any number other than 1 and itself. So, we can set out on that task, iterating through all numbers a divisor, bingo, the number is not prime. Let’s code that logic in Java, just the way we described:

divisor){

There are at least two styles of programming in use to day, one more widely used than the other. Imperative

We started at the value of 2 and iterated through each number until we reach the target value. If the target was divisible by any index, we break out of the loop declaring that the number is not prime. If we com pleted the loop, we make one last check, to see if the

of primes.

That’s familiar code, but it’s primitive and low level.

A quick glance at the code, we see that the loop stands among the numbers in range – is lost.

Focusing on the Essence

Let’s try that exercise again, this time using a more de clarative style of functional programming, using Java 8 (see References.).

import { ( number, divisor){ } ( number){ number > && range(2,number) .noneMatch(index} }

In this version, we raised the level of abstraction and

concisely expressed: in the range of values from 2 to the given number (not inclusive) ensure none match

Functional code reads like the problem statement.

The focus here is on the essence – what we’re inter ested in rather than the mechanics of how to get that.

Imperative style feels like giving instructions to a toddler. Functional style feels like communicating with a responsible adult.

Let’s leave the primes examples behind for just a bit and explore other aspects with a few more examples.

Favoring Immutability

Functional style promotes immutability. Most of us are used to mutating variables. Sometimes it’s hard to imagine how we could solve a problem without muta

tion. Let’s look at an example. In the next code we use imperative style to total all even values in a collection. int int result = for(int e:values){ if 2 == ) } }

Given a list of values, once again in this example, we loop through the values cherry picking the even values and accumulating them. The result is being mutated repeatedly as we loop through the values. This has two limitations. The for loop provides only sequential looping and, furthermore, the mutation makes it harder to make the computation concurrent for a large list. Let’s rewrite this in functional style. int values.stream() . 2 == ) .reduce( ,Math: }

Let’s read that aloud to see what’s going on: Given a reduce (sum) the values using the addExact method, using 0 as the initial value, and return the result. This code also begins to read like the problem statement.

Again, we focus on what instead of how. Further more, we avoided mutability, that leads to fewer moving parts, and that, in turn, helps to minimize er rors. Later we will see how that can help with concur rency as well.

Favoring Functional Purity

a value of x = 5, what’s the result of the computation below?

your guess. Instead, ask yourself how you feel when had to decipher it. The chances are we would get con fused and get it wrong. We don’t have to endure that, ware to develop and to deliver value.

A pure function or expression does not modify or af outside. Pure functions are easier to understand as they have fewer moving parts. They’re also easier to test – for a given input, the output is always the same. We would need fewer tests for pure code than code

values.stream() . ( ::isEven) .map 2) . () orElse( } doubleFirstE ven method before we ponder further. (1, , ,4, ,6, 7,8, ,10

is referential transparency. The compiler can replace, where possible, the code with the result of the compu tation. Furthermore, the compiler can freely reorder expressions or functions that are pure. That ability to dynamically optimize code is very useful to exploit concurrency on multicore processors.

We saw that functional style promotes declarative code and favors immutability. In addition, functional style brings higher order functions. A higher order function can accept functions as parameters, may create functions, and may return functions. In other words, we can do with functions what we’re used to do with objects. This leads to some powerful capabili ties, one of which is lazy evaluation.

Since we can pass functions to functions, instead of evaluating the parameter function before the call, we can postpone its evaluation for later (or even skip it).

faster, but avoiding things that don’t have to be done. faster, but by avoiding those that shouldn’t be done

Let’s look into an example of laziness. In the double FirstEven method we take a list of values even values, double each of them, but only pick the (int number){ System.out.println(“isEven called for “+num

We called the doubleFirstEven method with a list of ten values. Let’s take a look at the output from this code. In the previous example, the method picked only the values for which the invoked method (isEven) re turned true and the map method transformed the val ues by doubling them. Finally the method

int ues){

Even though we had ten values in the input list the isEven method was evaluated only twice. This is due to lazy evaluation of the functions presented to the and map methods. Rather than evaluating the argument functions right away the Stream (which is part of Java 8, other languages have similar data structures) postpones their evaluation. Furthermore, the Stream fuses the methods together, optimizing the execution to only the most essential steps. While this involves quite a bit of complexity under the hood, such optimization is possible due to function purity.

Easy Concurrency

Let’s revisit the isPrime example that we looked at in the beginning of the article. If the candidate number for prime check is small, then the time taken is not

If the number is large, we would want to employ mul tiple threads, especially on a multicore processor.

If we started with the imperative style code, turning that into multithreaded code is not easy. We have to split the results across threads, and then merge back and error prone.

Making the function style code concurrent is almost

do that for us and we only have to give it a nod. Let’s see how.

a function named isPrimeSequential ( number){ number > && range(2,number) .noneMatch(index-

}

We iterate on a range of values, looking for the pat tern of divisibility.

For large numbers, we can make the computa

the Stream library in Java 8 does that already and all we have to do is simply ask, like in the next example. ( number){ number > && range(2,number) .parallel() .noneMatch(index-

is a skill; it involves a decent amount of unlearning, relearning, and reevaluation.

not expect to get good at it instantly.

know it’s time to take a break when you’re fixated to review and fix code printed on the back of someone’s T-shirt.

Dr. Venkat Subramaniam is an award-winning author, founder of Agile Developer Inc., and an instructional professor at the University of Houston.

He has trained and mentored thousands of software developers in the US, Canada, Europe, and Asia, and is a regularly invited speaker at several international conferences. Venkat helps his software projects.

Venkat is a (co)author of multiple books, including the 2007 Jolt Productivity award-winning book Practices of an Agile Developer. His latest book is Functional Programming in Java: Harnessing the Power of Java 8 Lambda Expressions.

You can reach him by email at venkats@agiledeveloper.com or on

We used the parallel() method on the Stream to turn the lazy collection into a lazy parallel collection. Un der the hood the library uses a special kind of iterator called a spliterator to parallelize the execution. Let’s measure the time for the two versions.

number = System.out.println(TimeIt.code(()-> new MeasurePrime().

System.out.println(TimeIt.code(()-> new MeasurePrime().isPrimeConcurrent Here’s the output from this code.

As we can see there is a substantial speed improve ment between the sequential and the concurrent ver on our part. The JDK library took care of most of the work for us and all we had to do was provide it a few pure functions.

Recap of programming in this article. Overall we are able to

Declarative code keeps us focused.

The what can be varied independent of the how.

The code begins to read like the problem statement.

Has reduced chance of errors due to fewer moving parts.

Easier to test due to purity.

Once we get our heads wrapped around it, it is a pure joy to program in functional style.

You can access the code for the article from github.com/healthycodemagazine/May2014 References

Java 8 Download: html.

Venkat Subramaniam, Functional Programming in Java: Harnessing the Power of Java 8 Lambda Expres sions. Pragmatic Bookshelf, 2014. com/titles/vsjava8

May 2014

Venkat

Shyamala Prayaga is a seasoned UX (User Experience) designer at Amazon. She specializes in mobile and web usability standards and accessibility. She designs and delivers cross platform mobile-user experi ence across iPhone, Android, Blackberry, Palm Pre and Win dows Mobile, and is passionate about speaking at conferences and workshops. Healthy Code spoke to Shyamala about the future of Android design, and here are the excerpts:

The Future of Android Design

as your calling in life?

Interesting question! Design has always been my passion and I feel like a born designer. During nal workshop on usability, which was a paradigm shift for me. That’s when I realized designing is not only making things beautiful, but also making things usable irrespective of age, ability and situa

tion. That one workshop changed the way I think and work, and that’s when I decided to become a UX Designer.

What was the best Android UX project you have worked on? Why?

For any designer, all their projects are the best as every design has a challenge and a learning experi ence.

Shyamala Prayaga

Jokes apart, one of my best Android UX projects was an automotive shopping tool. When a user decides to buy a vehicle, there's a lot of market research, friends reviews and competitive analy sis. After all the research done, sometimes there's a long waiting period to purchase the shortlisted model, because it may not be available with the dealer, or the desired color is not available and so

shortlisted model/color with some other dealers with less or no waiting time and purchase them? We were trying to solve this problem and the so

Number) Scanning. Designing the whole UX for this application was so challenging and fun.

What do you see as the biggest challenge in designing for Android Mobile?

Almost every year Android comes up with a big release of their operating system, leaving apart the frequent patches, which brings in lot of UX and UI changes too. Since the design principles are still not consistently moving in one direction, it becomes something that’s sustainable for a longer period. This leaves designers to think in one direction and revamps, which I think is a big challenge. Is there such a thing as a mature design?

Before talking about mature design, we need to ask ‘What is a design?’ In my opinion, design is a solution to a problem that you have. There can be many ways to solve the same problem through various designs. Some can be very complicated, some can be straightforward and simple, and some can be intuitive.

I would say any design is mature, if it is able to achieve the goal it was intended for with minimum

What does Android design have in store for the future?

I think future Android design will include Aug mented Reality, Gesture Based Interaction and Voice Based Interactions.

What do you mean by Augmented Reality?

This is a very interesting concept and an emerg ing technology where we can map the virtual re ality with the actual reality and interact with the applications. With Augmented Reality catching interactions, so why would Android lack behind? would be Augmented Reality based.

Imagine I am using an online shopping application and can try products real time using the mobile’s camera and augmenting self live, as in a mirror.

Or imagine playing cricket on a smartphone and augmenting yourself as one of your favorite play ers. How much fun would it be!

You also mentioned Enhanced Gesture Based Interactions. What is that?

Android smartphones have become a one-shop stop for all the needs of the users right from online banking, shopping, playing games, and reading books. Ah, reading books, interesting!

Imagine reading e-books by just using hand ges tures and camera sensors, rather than swiping, tapping, pinching etc., to turn pages, zoom pages,

and more. Rather than using a touch or swipe to scroll pages in my application, just by using ges tures, I can control the entire application. Wouldn’t that be fun?

This is the future of Android design, which I fore see for all the reading needs.

How does Voice Based Interactions work?

Imagine how easy it would have been if you could speak and control interactions of your smartphone, like a robot:

By speech you could decide which applica tion you want to open, download, browse, inter act with.

By speech you could decide whom to call, what to search for etc.

By speech you could draft a huge mail, mes sages, status messages of social apps like FB, WhatsApp.

By speech you share images, videos, send

as a future concept that Android would try.

With Facebook acquiring WhatsApp, Social Media and Instant Messaging have gained lot of momentum and competition.

How do you predict the future of messag ing in Android?

quent upgrades it is making to its Hangout. I pre dict a universal messaging system as the future of Android Mobile, where rather than having sepa rate applications for video calling, voice calling, instant messaging and emailing, they would pro vide an all-in-one solution where the UI will be slip between functionalities.

Or who knows, maybe Android mobile would ship it as a default in-built functionality of the fu ture devices.

Every Android release has a unique play ful name. Can you guess what the next one would be?

Looking at the past trends with Android coming up with interesting names like KitKat, Jelly Bean, Ice Cream Sandwich, Eclair, the interesting future name could be chocolates like “Perk”, “Crunch”, “Snickers” or some deserts name like “Cheese Cakes” or “Rice Pudding.” Alphabetically, Lolli pop or Lemon Pie sounds perfect, but I am sure it won’t be Apple Pie!

Bharadwaj is a product manager at Appnomic Systems in Bangalore. hosted by Multunus in Bangalore and conducted by Venkat Subramaniam. Here’s a sneak-peek of the event from his eyes.

Have you been to a Code Retreat lately?

Bharadwaj

What is a Code Retreat?

Code retreats are day-long coding fests. Program mers take a crack at solving Conway’s Game of Life Puzzle in multiple short sessions. Each session is for 45 minutes. Developers work in pairs (miniature ex treme programming sessions). Every session starts with a clean slate, that is, no carryover code at all. Test Driven Development (TDD) is encouraged. After ev ery 45-minute session, a 15-minute stand-up meeting follows where everyone gets to share his or her expe rience and things that they have learnt. At the end of the stand-up, the group may decide to impose some constraints for the next session like not using classes, no global state, no-returns-from-any-methods, etc. The choice of programming language, framework and design are all left to the pair. This meet-up at Mul tunus had close to 25 programmers who kept on hack ing away the whole day.

Conway’s Game of Life alive or dead. Every cell interacts with its eight neigh bors (just like the good old Tic-Tac-Toe game grid).

Any live cell with fewer than two live neigh bours dies, as if caused by under-population.

Any live cell with two or three live neighbours lives on to the next generation.

Any live cell with more than three live neigh bours dies, as if by overcrowding.

Any dead cell with exactly three live neigh bours becomes a live cell, as if by reproduction.

You can learn more about the game at en.wikipedia.org/wiki/Conway's_Game_of_Life

solve the puzzle along with writing tests (remember, we are using TDD) especially, if one is a newbie to ei ther the puzzle or the language chosen. However, the fun is not in solving the puzzle itself, but it lies in the

One can read more about the format and structure of

Code Retreat at the community websiteMy Experience

I, along with my partner (pair programmer), programmed in 4 languages, namely - Scala, JavaScript, Python and Ruby! Here is a brief on each of my sessions.

Session I – Dive into Scala Programming

Both my partner and I had prior experience with the language. Thankfully, my partner was fa miliar with the problem too. We quickly discussed and zeroed in on a subset of the problem we ing in Game of Life) and agreed on a simple design. We started

The test part straightaway ex posed my poor knowledge of the ScalaTest. Later while writ ing code, we got stuck in trying to write object equality in Scala - something I could do with my eyes closed in Java. That was the second time my limitations were exposed. We programmed on my partner’s computer, and he used Gradle, which was a

Session II – Playing with JavaScript

JavaScript (JS) was common lingo with my next pair-pro gramming partner in the sec ond session. Neither of us had used any testing frameworks in

JS ever. That straightaway exposed our weakness! Since we did not have time to learn a new framework we decided to hand-code the tests. I remem ber writing some code that seemed to solve something. Along the way I re-discovered the right way to write inner functions in JavaScript. That was the highlight for me!

Session III – Back to Scala

The next session had me pairing up with a Java guy who wanted a sneakpeek into Scala. This time we used my laptop to code. In order to give him text-editor. I wanted to stay clear of ScalaTest and Scala’s build system - so as to give my partner a good look at some mass of code and not distract him

While coding, I had this nagging realisation that I had not understood the problem well enough. I wanted some thinking-time away from coding and just focus on the puzzle. We were nearing lunch time also. So I decided to

Session IV – Playing with Python

in Python. This guy had given a good thought into the problem and the approach we came up with was very refreshing! He coded away in Python, which I found easy to follow, and we wrote a lot of code. We were quite close to solving one of the situations in the game when the time ran out. Writing so much code to solve the problem meant that the test code was mini mal during this session. However, I was beginning to appreciate the complexity and immense freedom of design that this simple-looking puzzle posed at us.

Session V – Rolling with Ruby

There were lot of Ruby developers in the group, and I was very curious to get a feel for this language. So I chose a Ruby-man for the last session. This person was much younger than me but surprised me by his thor ough approach to TDD. He insisted on evolving the test code almost simultaneously with the main code, and I must admit, it did frustrate me initially. I wanted to write a blob of test code, write a blob of solution code, and keep alternating between the two. However, my partner, who was the one coding in Ruby, would have none of it. He requested that we keep shifting gears between the test-code and solution-code for ev ery few lines of code. I knew he had a good point in what he was suggesting, and asked if he was really able to code like that in his work. His answer was af

ated the young programmer’s discipline.

Epilogue

It’s not every day that I force myself to think on good programming problems. This was an excellent oppor tunity for that. That itself made me immensely happy. I was split on approaching the problem from a bot tom-up or top-down approach – which had me think ing about an aspect of design that I had not thought for some time. I don’t remember the last time I pair programmed before this event. It’s a fabulous thing, and I want to grab every opportunity of doing so in future as well. The code retreat certainly pushed me away from my comfort zone, and that’s a great way to learn. Having not solved the problem still nags me. One of these days, I will sit down to write code that solves Conway’s Game of Life to at least some extent.

Already, a few approaches are brewing in my head. I recommend Code Retreat to all developers. Try to get in the next time it is happening somewhere nearby in your city.

Last but not the least, Venkat put forth some wonder ful thoughts on the endeavour of software develop ment. I also saw a great start-up in Multunus. The day was a delight. Big thanks to all my partners in Code Retreat, and all those who made the event possible. If it comes around, I am going again.

Bharadwaj

Pragmatic Programmer Quotes

Bharadwaj works as a technical product manager at Appnomic, and was previously with HP. He programs mostly in Scala and JavaScript, and is also quite comfortable with Java and Octave. He has done his MBA from IIMB.

We all want to create a simple design, but the act of creating such a design is not that simple. We looked at this problem and said we can solve it using a pool of threads. Now we have a pool of problems.

Our field has fundamentally transformed in the last two decades, from developers fighting DLL hell to fighting assembly and jar hell.

Coming up in the June issue Functional Hygiene: Reasons to Avoid side effects

– Dr. Venkat Subramaniam

Functional programming promotes pure functions or functions with no hygiene while programming has a purity with examples.

Get your Grunt on - Rocky Jaiswal

With time developers soon realized that JavaScript, the most used language of the web is missing a proper build system and JavaScript task runner. Do you want to run your JavaScript tests? Grunt has it covered;

Interview with

On the Way to Ember - Data 1.0

production? Well, Grunt takes care of that too. This article will talk about playing with Grunt in web applications. and technology conference speaker gave an exclusive interview to Healthy Code when he about the current state of Groovy and Grails and the issues companies face in moving away from Java to embrace it. He discussed the latest web favorite HTML 5 and how it has changed the way web applications are developed today. He also spoke about several toolkits and libraries that are popular among developers.

– Abhimanyu Chakravarty Owned and Published by T. Sivasubramanian. Published from 11/6, First floor, Fourth street, Padmanabha Nagar, Adyar,Chennai600020 and printed by M. Elumalai, at Sakthi Scanners (P) Ltd, 7, Dams Road, Chindadripet, Chennai - 600002. Editor: S.Prabhu.

Ember-Data is a module of Ember.js that allows us to bind our client side logic seamlessly with backend services. It has been coming for quite a while and needless to say, even in its nascent stages, it managed to make our lives much easier than what it used to be. Now we have reached a stage where EmberData 1.0 seems almost around the corner. This article aims to familiarize the reader with Ember-Data’s functionality and philosophy.