Sentiment analysis, an area of Natural Language Processing (NLP), is the computational study that seeks people’s attitude, positive or negative, about a particular topic by analyzing their written sentences or documents. It is also known as opinion mining and concerned with people’s sentiments, opinions, attitude, evaluations, appraisals and emotions towards various entities such as products, organizations, services etc.

This project presents a sentiment analysis task performed in Hadoop environment using the MapReduce technique. Hadoop was accessed through the BigInsights service offered by the IBM cloud Bluemix. The sentiment analysis program was tested on a large corpus of sentiments of 1.9 GB size. More details and source code can be found at Sentiment Analysis

Reinforcement Learning is a goal-oriented machine learning technique where an agent automatically learns to solve a problem by interacting with its environment. An agent makes decision based on its policy, and may receive rewards or punishments depending on whether the decision is taking it towards or away from the goal. Through a trial and error process it tries to maximize the rewards. Q-Learning, SARSA, DQN are examples of reinforcement learning algorithms.

This project programs an agent to reach to a goal state automatically in a world of 150 states. Q-Learning was used to train the agent. To find more details and source code of the project please visit Reinforcement Learning Project Page

Software defect prediction aims to find defect prone source code, and thus reduce the effort, time and cost involved with ensuring the quality of software systems. Both code and non-code metrics are commonly used in this process to train machine learning algorithms to predict software defects. Studies have shown that such metrics-based approaches are failing to give satisfactory results, and have reached a performance ceiling.

This project explores the idea of using code profiles as an alternative to traditional metrics to predict software defects. Unlike traditional metrics-based approaches, this project uses vectors generated by analyzing language feature use from the parse trees of source code as feature variables to train machine learning algorithms. Two benchmark bug datasets, the Eclipse bug dataset and the Github bug database, have been used to train the models. Experimental results using learning algorithms encourages us to use software code profiles as an alternative to traditional metrics to predict software defects.This code profile-based method proves to be more promising than traditional metrics-based approaches. Instructions to replicate this project is available at Defect-Prediction-Using-RCLUV

Like natural languages programming languages also evolve over time. After releasing a programming languge, developers add new features to meet the needs of programmers, and remove features which are not efficient or simply a bad idea.

This is a grammar-based project that automatically extracts the use of language features from the parse tree of source code. Based on the discovered use of frequency developers can make important decisions like removing or improving a particular feature. A large corpus of PHP source code has been analyzed in this project to find the usage frequency of different PHP features. PHP feature analysis results and source code are available at PHP Feature Analysis

Cloudant is a fully managed and distributed Database as a Service (DBaaS) platform from IBM to create and manage NoSQL (Not only SQL) JSON (JavaScript Object Notation) documents. It is highly scalable, available and secured. Horizontal scaling, geo load balancing, auto sharding and rebalancing of data, and integrated IO monitoring and prioritization have made Cloudnat massively scalable. Data in Cloudant is also highly available because it triplicates data in three different servers, and performs auto sharding and rebalancing to avoid the effect of server failure and maintenance. Data gets various security measures provided by the hosts such as certification, virus scanning and so on. Cloudant also ensures access security through authentication, encryption etc.

This writing provides basics of Cloudant architecture and shows how to perform basic NoSQL operations. Source code is available at NoSQL on IBM Cloudant

All programming languages need to be updated regularly by adding new features that fill programming needs. Existing approaches to determine new language features are completely manual and are based on language developers' experience, source code analysis, feature requests, and programmer interviews. Although these are acceptable practises, they are time-consuming and require a lot of brainstorming tasks, such as preparing interview questions, understanding ambiguous ideas, finding the common requirements, etc.

This project uses a systematic approach for identifying language features with the help of pattern and clone detection tools that work on source code. It semi-automates the task of feature identification, works quickly, and reduces the effort involved in existing practises. We identify features for the TXL language by implementing our idea and enabling the NiCAD clone detector to perform clone analysis on TXL source code, and developing a pattern detector. After detecting code patterns with the pattern detector and analyzing them, we propose eleven new features to TXL language developers that can help improve the feature set of TXL. Details with source code can be found at NiPAT

Change in software code is inevitable. Identifying change-prone source files before releasing a software can save the extra efforts and costs required to identify and modify them once released. Manually identifying which source files may require changes in future is almost impossible for many reasons such as the size of a codebase.

Machine learning is often used to perform various prediction tasks. This project trains trending machine learning algorithms with codebase change history of two php projects, and predicts which files may require change in future. It uses language features extracted from language grammar as feature variables and change history as labels. In this process each source file is encoded using the usage frequency of different language features. Experimetal results show promising performance. It can help software developers to take precautionary steps to reduce changes in codebase before releasing a software. Details of the project and source code is available at Source File Change Prediction

Forking and modifying an existing Jekyll template is one of the easiest ways to build GitHub blogs. But if you prefer some adventure and want to experiment eveything from scratch then this post is for you!

To create a blog on GitHub at first you need a GitHub account. After log in to your account you will see a panel on the left to create a repository. Create a new repository and name it your_user_name.github.io. When creating the repository make it public, you may skip Initialize the repository with a ReadMe file, choose a licence of your preference. After creating the repository you will get the address of the repository similar to https://github.com/your_user_name/your_user_name.github.io.git.

Use the git tool to clone the repository to your own machine.
$git clone https://github.com/username/username.github.io

Now download and install the Jekyll tool. This tool will mainly build your website. It has noting to do with GitHub. Open the Windows command prompt and check the Jekyll version to ensure it has been installed successfully.
jekyll -v

Now set the path of the command prompt to your cloned repository your_user_name.github.io.git and give the following command. The dot (.) here is part of the command.
jekyll new .
if you have pre-existing files in your repository then jekyll new . --force

It will create the structure of your website. Jekyll can help you to see the website on your localhost. Run the following command on Windows command prompt.
jekyll serve
If it doesn't work then try the following command.
bundle exec jekyll serve

It will generate a server address (http://). Copy-paste that to your browser. Your Blog is ready. Congratulations!
Now you can go online pushing your site to your GitHub account. Use the Git bash to give the following command on you project directory
$git add --all
$git commit -m "Initial Commit"
$git push -u origin master

Now go to to your GitHub repository (refresh if it is already open). It should show the uploaded project in the master branch. Go to the Settings of your repository. Under the GitHub Pages section select a Source branch (for example the master branch). The page will refresh and you will find the link of your website. If it's showing Your site is ready to be published at http:// then wait a while and refresh your page. It will change to Your site is published at http://.

Your blog is online now, but it's holding only the default contents. You can customize it in your own way. One starting point is _config.yml. To publish your blog content modify following the format of the post given as an example inside the directory _posts. The link to your post will appear automatically in your Front matter.

You can customize your blog directly on GitHub or on your local machine. If you work on your local machine you can use VSC (Visual Studio Code) ( or a text editor will also do).

After modifying your code, save it and check the website using Jekyll on your own machine
jekyll serve

If Jekyll is already running simply refresh the page. If the contents of the page doesn't change even after refreshing then stop Jekyll and try
bundle exec jekyll clean
jekyll serve

When satisfied commit the changes using git bash and push it to your GitHub account.