Author: neo

How to write better code collaboratively using Linter? 

How to write better code collaboratively using Linter?

As a software development team grows larger and larger, problems can start to appear as people who came from different backgrounds will have different ways to write the same line of code.

What is a better way of naming variables? What is the maximum characters allowed in a single line? These are the common problems developers faced.

The struggle is real. (Image Source: http://while2.ghost.io/why-tabs-are-better-than-spaces/)

Linter + Configuration files is the solution. This article looks at how to write better code based on learnings from the community and eventually create your own standards to suit your own needs.

What is a linter?

The definition for linter from Wikipedia is as follows:

Generically, lint or a linter is any tool that detects and flags errors in programming languages, including stylistic errors.

So a linter helps in detecting programming errors (such as division by zero) and stylistic errors (such as not aligning the codes properly).

Linter In Action!

The list of rules set in linters are usually determined by the community, however you are free to make customisations to suit yourself better.

How does linter helps us?

As demonstrated in the previous section, linter helps us in detecting errors while we write code.

Instead of having our peers review possible errors when we submit a Pull Request for our work, we are notified about the possible errors in our codes even before we commit our changes.

Essentially we are changing the work flow of Pull Requests from the following:

Pull Request Workflow without linter

To the following:

Pull Request Workflow with linter

At first glance, it might seem like we have just added an additional process in our workflow.

However this brings several benefits:

Firstly, by having the linter to comment on your code it helps save time waiting for peer reviews and having to push code again just to make the changes.

Secondly, it helps to reduce possible syntax errors / stylistic errors from the code that are being submitted and it allows your reviewers to focus only on possible logical errors.

Eventually what it leads to by having a common linter among different developers in your team is that it helps establish standard in your code.

Setting Standards

  • What is the maximum allowed characters in a single line of code?
  • Which character are we using to separate different words in variables for CSS? Hyphen or Underscore?
  • How should we align a private method?

These are the part of the essential questions that are being asked from day to day by different developers and people may have different answers to each of the questions above.

By creating a repository that contains the configuration files for different linters, we are giving direction for all the developers in the organization to follow the standards that were predefined.

Having the linter configuration file set up properly is important

If you have ideas / feedback on how the standards should be changed, submit a pull request, create discussions and gather feedback from your peers on why the changes are needed.

How to use linter?

  1. Find the linter for your languages

A variety of linters exists for different languages thanks to the community that has been developing them.

A list of popular Linters for different languages is as follows:

2. Configure your text editor

Linters works by checking for errors by inspecting the content of the files. However, plugins have been developed so that linters can be executed automatically alongside your favour text editor:

3. Define your rules

The rules for each language are different and most likely, you will find rules being configured in yaml format(An example here).

You are allowed to customize the yaml file to suit your usage better. Example: Naming convention of variables in sass-lint is hypenated_lowercase by default. However you can change it to camel_case or snake_case (or even choose to provide it as a regular expression) in here easily.

Integrating linter with your text editor

If you are using linter together with your text editors, the linter will search for the configuration file in the following hierarchy:

Inline overrides
Inline settings
.sublimelinterrc settings
Project settings
User settings # this is important
Default settings

(Referenced from: http://www.sublimelinter.com/en/latest/settings.html?highlight=project#settings-stack)

What does this mean for us?

  1. Default configuration files will be followed if no configuration is found
  2. Most importantly, it means that you can define rules for your machine per User . The configuration file can be stored inside your machine’s user directory and it will be applied to all the files that you opened using your text editor. (Meaning that you don’t have tocopy-paste the configuration files all over different folders)

Automated code review

Code Review can be performed automatically

To level the code review process, automated code review can be performed by using third party services such as Hound.

By configuring Hound and integrating it with GitHub, the code review can be done automatically.

Uh-Oh! Someone is not following the rules…

This helps in reviewing possible code errors that developers may have missed.

There it is. This is how we use tools to help us write better code. Hope this helps you in writing better code!

[PYTHON] Scan all your local directory files

Scan local files in directory

At certain times, we may need to perform scanning for all the files stored in local directory. We can perform so using the code as follows:


import os
    # scan all files in directory
    for file in os.listdir('.'):
        if file.endswith('.json'):
             # perform action here
             print(file) # for testing purpose, we are merely print the file names

However, printing the file names may not be enough. Let’s try to perform some further actions: read and scan all the json files in the local directory, combine (remove duplicate) and print it out!


import os
import json

# defining the lists
all_json = []
    # scan all files in directory
    for file in os.listdir('.'):
        if file.endswith('.json'):
            # action starts here
            with open(os.path.abspath('') + '/' + file) as f:
                # to union: convert the list into set
                # and uses "|" to UNION it
                all_json = list(set(all_json) | set(json.load(f)))
                # Sort the lit
                all_json.sort()

# print the combined jsons
print(all_json)

[Java] RMI Simple Server Example using Terminal

Today we will be discussing about Java RMI Server.

What is RMI Server?

Typical implementation of Java RMI using Stub and Skeleton objects.
Java RMI Implementation (Image credits: Wikipedia)

According to Wikipedia, Java Remote Method Invocation (RMI) is

“A Java API that performs the object-oriented equivalent of remote procedure calls (RPC), with support for direct transfer of serialized Java classes and distributed garbage collection.”

What is Remote Procedure Call?

Remote Procedure Call, Image Courtesy of The State University of New Jersey

 

Again, according to Wikipedia, Remote Procedure Call is:

“An inter-process communication that allows a computer program to cause a subroutine or procedure to execute in another address space (commonly on another computer on a shared network) without the programmer explicitly coding the details for this remote interaction.”

Long story short, Java RMI / RPC allows an Class to invoke (access) methods from another server as if the methods is placed on the same machine as the Class itself.

Continue reading “[Java] RMI Simple Server Example using Terminal”

[Android] Fetch Data using URL Link (JSON/XML)

As usual, before getting into this tutorial, you need to know how an android application code works and how different important file interact with each other (To be updated)

1. Insert the following into your Manifest.xml (AndroidManifest.xml, understand the tab) to enable the permissions to access internet

 <!-- Adding for accessing internet -->
 <uses-permission android:name="android.permission.INTERNET" />

2. Create the following method to read Data from internet

/**
     * Get Data, based on url input
     * @param urlPath path linked to the data
     * @return null if not data is found, or String if there is data
     */

    public static String readURL(String urlPath) {
        // These two need to be declared outside the try/catch
        // so that they can be closed in the finally block.
        HttpURLConnection urlConnection = null;
        BufferedReader reader = null;
        // Will contain the raw text response as a string.
        String textStr = null;
        try {
            // Construct the URL based on the link provided
            URL url = new URL(urlPath);

            // Create the request to the link provided
            urlConnection = (HttpURLConnection) url.openConnection();
            urlConnection.setRequestMethod("GET");
            urlConnection.connect();

            // Read the input stream into a String
            InputStream inputStream = urlConnection.getInputStream();
            StringBuffer buffer = new StringBuffer();
            if (inputStream == null) {
                // Nothing to do.
                textStr = null;
            }
            reader = new BufferedReader(new InputStreamReader(inputStream));
            String line;

            // Reading the strings line by line and append new line (\n)
            while ((line = reader.readLine()) != null) {
                buffer.append(line + "\n");
            }

            if (buffer.length() == 0) {
                // Stream was empty. No point in parsing.
                textStr = null;
            }
            textStr = buffer.toString();
        } catch (IOException e) {
            Log.e("PlaceholderFragment", "Error ", e);
            // If the code didn't successfully get the string, there's no point in attempting
            // to parse it.
            textStr = null;
        } finally{
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
            if (reader != null) {
                try {
                    reader.close();
                } catch (final IOException e) {
                    Log.e("PlaceholderFragment", "Error closing stream", e);
                }
            }
        }

        return textStr;
    }

3. Then you can call the above method, which will attempt to read the data based on the link that you have provided! Android development recommends the usage of Thread to retrieve data so that the operation of application is not interrupted by the data retrieve process. (To be updated)

4. That’s all! Try to code it now!

Reference:
1. Connecting to the Network, Android Development: http://developer.android.com/training/basics/network-ops/connecting.html
2. Data retrieve methods from github: https://github.com/stilva/udacity-dev-android/blob/master/app/src/main/java/com/stilva/android/sunshine/app/FetchWeatherTask.java

[Android] Get your GPS Coordinates

Before getting into this tutorial, you need to know how an android application code works and how different important file interact with each other (To be updated)

1. Insert the following code into your Manifest.xml to enable accessing location services:

<!-- Adding for accessing location -->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_LOCATION_EXTRA_COMMANDS" />

2. Add the following code to onCreate() in your Activity.java


// Get the location manager
locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
locationListener = new myLocationListener();

locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0 , locationListener);
locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0 , locationListener);

3. Lastly, create a private class inside your Activity class


private class myLocationListener implements LocationListener {
@Override
public void onLocationChanged(Location location) {


if(location != null) {
Toast.makeText(LocationService.this,
location.getLatitude() + "\n" + location.getLongitude(),
Toast.LENGTH_LONG).show();
}
else {
}
}

@Override
public void onStatusChanged(String provider, int status, Bundle extras) {  }

@Override
public void onProviderEnabled(String provider) {
Toast.makeText( getApplicationContext(),"Gps Disabled", Toast.LENGTH_SHORT ).show();

}

@Override
public void onProviderDisabled(String provider) {
Toast.makeText( getApplicationContext(),"Gps Enabled", Toast.LENGTH_SHORT ).show();
}
}

 

There you go! Try the code now!