trackler 2.0.0.1 → 2.0.0.2

data/tracks/go/exercises/nucleotide-count/example.go

@@ -5,12 +5,18 @@ import (
 	"strings"
 )
 
+const testVersion = 2
+
+// Histogram is a mapping from nucleotide to its count in given DNA
 type Histogram map[byte]int
 
+// DNA is a list of nucleotides
 type DNA string
 
+const validNucleotides = "ACGT"
+
+// Count counts number of occurrences of given nucleotide in given DNA
 func (dna DNA) Count(nucleotide byte) (count int, err error) {
-	validNucleotides := "ACGT"
 	if !strings.Contains(validNucleotides, string(nucleotide)) {
 		return 0, errors.New("dna: invalid nucleotide " + string(nucleotide))
 	}
@@ -18,11 +24,18 @@ func (dna DNA) Count(nucleotide byte) (count int, err error) {
 	return strings.Count(string(dna), string(nucleotide)), nil
 }
 
-func (dna DNA) Counts() Histogram {
-	a, _ := dna.Count('A')
-	c, _ := dna.Count('C')
-	t, _ := dna.Count('T')
-	g, _ := dna.Count('G')
-
-	return Histogram{'A': a, 'C': c, 'T': t, 'G': g}
+// Counts generates a histogram of valid nucleotides in given DNA.
+// Returns error if DNA contains invalid nucleotide.
+func (dna DNA) Counts() (Histogram, error) {
+	var total int
+	h := Histogram{}
+	for i := range validNucleotides {
+		nucleotide := validNucleotides[i]
+		h[nucleotide], _ = dna.Count(nucleotide)
+		total += h[nucleotide]
+	}
+	if total != len(dna) {
+		return nil, errors.New("dna: contains invalid nucleotide")
+	}
+	return h, nil
 }

data/tracks/go/exercises/nucleotide-count/nucleotide_count_test.go

@@ -1,27 +1,12 @@
 package dna
 
-import "testing"
-
-func (h Histogram) Equal(o Histogram) bool {
-	return h.sameLength(o) && h.sameMappings(o)
-}
-
-func (h Histogram) sameLength(o Histogram) bool {
-	return len(h) == len(o)
-}
-
-func (h Histogram) sameMappings(o Histogram) (res bool) {
-	res = true
-	for k := range h {
-		if h[k] != o[k] {
-			res = false
-		}
-	}
-	return
-}
+import (
+	"reflect"
+	"testing"
+)
 
 var tallyTests = []struct {
-	strand     string
+	strand     DNA
 	nucleotide byte
 	expected   int
 }{
@@ -33,9 +18,9 @@ var tallyTests = []struct {
 
 func TestNucleotideCounts(t *testing.T) {
 	for _, tt := range tallyTests {
-		dna := DNA(tt.strand)
-		count, _ := dna.Count(tt.nucleotide)
-		if count != tt.expected {
+		if count, err := tt.strand.Count(tt.nucleotide); err != nil {
+			t.Fatal(err)
+		} else if count != tt.expected {
 			t.Fatalf("Got \"%v\", expected \"%v\"", count, tt.expected)
 		}
 	}
@@ -43,11 +28,7 @@ func TestNucleotideCounts(t *testing.T) {
 
 func TestHasErrorForInvalidNucleotides(t *testing.T) {
 	dna := DNA("GATTACA")
-	count, err := dna.Count('X')
-	if count != 0 {
-		t.Fatalf("Got \"%v\", expected \"%v\"", count, 0)
-	}
-	if err == nil {
+	if _, err := dna.Count('X'); err == nil {
 		t.Fatalf("X is an invalid nucleotide, but no error was raised")
 	}
 }
@@ -58,37 +39,57 @@ func TestHasErrorForInvalidNucleotides(t *testing.T) {
 func TestCountingDoesntChangeCount(t *testing.T) {
 	dna := DNA("CGATTGGG")
 	dna.Count('T')
-	count, _ := dna.Count('T')
-	if count != 2 {
-		t.Fatalf("Got \"%v\", expected \"%v\"", count, 2)
+	count1, err := dna.Count('T')
+	if err != nil {
+		t.Fatal(err)
+	}
+	count2, err := dna.Count('T')
+	if err != nil {
+		t.Fatal(err)
+	}
+	if count1 != count2 || count2 != 2 {
+		t.Fatalf("Got %v, expected %v", []int{count1, count2}, []int{2, 2})
 	}
 }
 
 type histogramTest struct {
-	strand   string
+	strand   DNA
 	expected Histogram
+	err      bool
 }
 
 var histogramTests = []histogramTest{
 	{
 		"",
 		Histogram{'A': 0, 'C': 0, 'T': 0, 'G': 0},
+		false,
 	},
 	{
 		"GGGGGGGG",
 		Histogram{'A': 0, 'C': 0, 'T': 0, 'G': 8},
+		false,
 	},
 	{
 		"AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC",
 		Histogram{'A': 20, 'C': 12, 'T': 21, 'G': 17},
+		false,
+	},
+	{
+		"GGXXX",
+		nil,
+		true,
 	},
 }
 
 func TestSequenceHistograms(t *testing.T) {
 	for _, tt := range histogramTests {
-		dna := DNA(tt.strand)
-		if !dna.Counts().Equal(tt.expected) {
-			t.Fatalf("DNA{ \"%v\" }: Got \"%v\", expected \"%v\"", tt.strand, dna.Counts(), tt.expected)
+		counts, err := tt.strand.Counts()
+		if tt.err && err == nil {
+			t.Fatalf("DNA{ %q }: expected error but didn't get one.", tt.strand)
+		} else if !tt.err && err != nil {
+			t.Fatalf("DNA{ %q }: expected no error but got error %s", tt.strand, err.Error())
+		} else if !tt.err && !reflect.DeepEqual(counts, tt.expected) {
+			t.Fatalf("DNA{ %q }: Got %v, expected %v", tt.strand, counts, tt.expected)
 		}
 	}
 }
@@ -97,12 +98,19 @@ func BenchmarkSequenceHistograms(b *testing.B) {
 	b.StopTimer()
 	for _, tt := range histogramTests {
 		for i := 0; i < b.N; i++ {
-			dna := DNA(tt.strand)
 			b.StartTimer()
 
-			dna.Counts()
+			tt.strand.Counts()
 
 			b.StopTimer()
 		}
 	}
 }
+
+const targetTestVersion = 2
+
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
+}

data/tracks/haskell/exercises/anagram/test/Tests.hs

@@ -24,7 +24,7 @@ specs = describe "anagram" $
                    . map fromList
                    $ candidates
 
--- Test cases adapted from `exercism/x-common/anagrams.json` on 2016-07-25.
+-- Test cases adapted from `exercism/x-common` on 2016-10-26.
 
 data Case = Case { description ::  String
                  , subject     ::  String
@@ -108,16 +108,6 @@ cases = [ Case { description = "no matches"
                , candidates  = ["patter"]
                , expected    = []
                }
-        , Case { description = "detects unicode anagrams"
-               , subject     = "ΑΒΓ"
-               , candidates  = ["ΒΓΑ", "ΒΓΔ", "γβα"]
-               , expected    = ["ΒΓΑ", "γβα"]
-               }
-        , Case { description = "eliminates misleading unicode anagrams"
-               , subject     = "ΑΒΓ"
-               , candidates  = ["ABΓ"]
-               , expected    = []
-               }
         , Case { description = "capital word is not own anagram"
                , subject     = "BANANA"
                , candidates  = ["Banana"]

data/tracks/java/bin/journey-test.sh

@@ -1,79 +1,67 @@
-#!/bin/bash
-SCRIPTPATH=$( pushd `dirname $0` > /dev/null && pwd && popd > /dev/null )
-EXECPATH=$PWD
-XAPI_PID=""
-
-# Makes CI output easier to read
-TERM=dumb
+#!/usr/bin/env bash
 
-function on_exit() {
+on_exit() {
   echo ">>> on_exit()"
-  if [ "$XAPI_PID" != "" ] ; then
-    kill $XAPI_PID
-    echo "Stopped X-API (pid=${XAPI_PID})"
+  if [[ "$xapi_pid" != "" ]] ; then
+    kill $xapi_pid
+    echo "stopped x-api (pid=${xapi_pid})"
   fi
   cd $EXECPATH
   echo "<<< on_exit()"
 }
 
-assert_gradle_installed() {
-  echo ">>> assert_gradle_installed()"
-  which gradle >/dev/null
-  if [ $? != 0 ]; then
-    echo "Gradle not found.  This the Java build tool and is required."
-    echo -e "Have you completed the setup instructions at https://github.com/exercism/xjava ?\n"
-    echo "PATH=${PATH}"
-    echo "aborting."
-    exit 1
-  fi
-  echo "<<< assert_gradle_installed()"
-}
+assert_installed() {
+  local binary=$1
+  echo ">>> assert_installed(binary=\"${binary}\")"
 
-assert_jq_installed() {
-  echo ">>> assert_jq_installed()"
-  which jq >/dev/null
-  if [ $? != 0 ]; then
-    echo "jq not found.  This utility is used to parse the config.json file and is required."
+  if [[ "`which $binary`" == "" ]]; then
+    echo "${binary} not found; it is required to perform this test."
     echo -e "Have you completed the setup instructions at https://github.com/exercism/xjava ?\n"
     echo "PATH=${PATH}"
     echo "aborting."
     exit 1
   fi
-  echo "<<< assert_jq_installed()"
+  echo "<<< assert_installed()"
 }
 
-assert_required_ruby_installed() {
-  echo ">>> assert_required_ruby_installed(\"$1\")"
-  local RACKAPP_HOME="$1"
+assert_ruby_installed() {
+  local ruby_app_home="$1"
+  echo ">>> assert_ruby_installed(ruby_app_home=\"${ruby_app_home}\")"
 
-  pushd "${RACKAPP_HOME}" >/dev/null
-  local CURRENT_RUBY_VER=`ruby --version | egrep --only-matching "[0-9]+\.[0-9]+\.[0-9]+"`
-  local EXPECTED_RUBY_VER=`cat Gemfile | awk -F\' '/ruby /{print $2}'`
-  popd >/dev/null
-  if [ "$CURRENT_RUBY_VER" != "$EXPECTED_RUBY_VER" ]; then
-    echo "${RACKAPP_HOME} requires Ruby ${EXPECTED_RUBY_VER}; current Ruby version is ${CURRENT_RUBY_VER}."
+  pushd "${ruby_app_home}"
+  local current_ruby_ver=`ruby --version | egrep --only-matching "[0-9]+\.[0-9]+\.[0-9]+"`
+  local expected_ruby_ver=`cat Gemfile | awk -F\' '/ruby /{print $2}'`
+  popd
+  if [[ "${expected_ruby_ver}" != "" && "${current_ruby_ver}" != "${expected_ruby_ver}" ]]; then
+    echo "${ruby_app_home} requires Ruby ${expected_ruby_ver}; current Ruby version is ${current_ruby_ver}."
     echo -e "Ruby used: `which ruby`.\n"
     echo -e "Have you completed the setup instructions at https://github.com/exercism/xjava ?\n"
     echo "PATH=${PATH}"
     echo "aborting."
     exit 1
   fi
-  echo "<<< assert_required_ruby_installed()"
+  echo "<<< assert_ruby_installed()"
 }
 
-clean_build() {
-  echo ">>> clean_build(\"$1\", \"$2\")"
-  local REPO_ROOT="$1"
-  local BUILD_DIR="$2"
+clean() {
+  local build_dir="$1"
+  echo ">>> clean(build_dir=\"${build_dir}\")"
 
-  if [ -d "$BUILD_DIR" ] ; then
-    echo "Cleaning journey script build (${BUILD_DIR})."
-    rm -rf "$BUILD_DIR"
+  # empty, absolute path, or parent reference are considered dangerous to rm -rf against.
+  if [[ "${build_dir}" == "" || ${build_dir} =~ ^/ || ${build_dir} =~ \.\. ]] ; then
+    echo "Value for build_dir looks dangerous.  Aborting."
+    exit 1
+  fi
+
+  local build_path=$( pwd )/${build_dir}
+  if [[ -d "${build_path}" ]] ; then
+    echo "Cleaning journey script build output directory (${build_path})."
+    rm -rf "${build_path}"
   fi
-  pushd ${REPO_ROOT}/exercises > /dev/null
+  cd exercises
   gradle clean
-  popd > /dev/null
-  echo "<<< clean_build()"
+  cd ..
+  echo "<<< clean()"
 }
 
 get_operating_system() {
@@ -102,131 +90,180 @@ get_cpu_architecture() {
   esac
 }
 
-fetch_exercism_cli() {
-  echo ">>> fetch_exercism_cli(\"$1\", \"$2\", \"$3\")"
-  local OS="$1"
-  local ARCH="$2"
-  local EXERCISM_HOME="$3"
+download_exercism_cli() {
+  local os="$1"
+  local arch="$2"
+  local exercism_home="$3"
+  echo ">>> download_exercism_cli(os=\"${os}\", arch=\"${arch}\", exercism_home=\"${exercism_home}\")"
+
+  local CLI_RELEASES=https://github.com/exercism/cli/releases
 
-  local LATEST=https://github.com/exercism/cli/releases/latest
+  local latest=${CLI_RELEASES}/latest
   # "curl..." :: HTTP 302 headers, including "Location" -- URL to redirect to.
   # "awk..." :: pluck last path segment from "Location" (i.e. the version number)
-  local VERSION="$(curl --head --silent $LATEST | awk -v FS=/ '/Location:/{print $NF}' | tr -d '\r')"
-  local CLI_URL=https://github.com/exercism/cli/releases/download/${VERSION}/exercism-${OS}-${ARCH}.tgz
+  local version="$(curl --head --silent ${latest} | awk -v FS=/ '/Location:/{print $NF}' | tr -d '\r')"
+  local download_url=${CLI_RELEASES}/download/${version}/exercism-${os}-${arch}.tgz
+
+  mkdir -p ${exercism_home}
+  curl -s --location ${download_url} | tar xz -C ${exercism_home}
+  echo "<<< download_exercism_cli()"
+}
+
+git_clone() {
+  local repo_name="$1"
+  local dest_path="$2"
+  echo ">>> git_clone(repo_name=\"${repo_name}\", dest_path=\"${dest_path}\")"
+
+  git clone https://github.com/exercism/${repo_name} ${dest_path}
 
-  mkdir -p ${EXERCISM_HOME}
-  curl -s --location ${CLI_URL} | tar xz -C ${EXERCISM_HOME}
-  echo "<<< fetch_exercism_cli()"
+  echo "<<< git_clone()"
 }
 
-fetch_x_api() {
-  echo ">>> fetch_x_api(\"$1\")"
-  local XAPI_HOME="$1"
+make_local_trackler() {
+  local trackler="$1"
+  echo ">>> make_local_trackler(trackler=\"${trackler}\")"
 
-  git clone https://github.com/exercism/x-api ${XAPI_HOME}
-  pushd ${XAPI_HOME} >/dev/null
-  git submodule init -- metadata
+  local xjava=$( pwd )
+  pushd ${trackler}
+  git submodule init -- common
   git submodule update
+
+  # Bake in local copy of xjava; this is what we are testing.
   rmdir tracks/java
-  ln -s $REPO_ROOT tracks/java
+  mkdir -p tracks/java/exercises
+  cp ${xjava}/config.json tracks/java
+  cp -r ${xjava}/exercises tracks/java
+
+  gem install bundler
+  bundle install
+  gem build trackler.gemspec
+
+  # Make *this* the gem that x-api uses when we build x-api.
+  gem install --local trackler-*.gem
+
   popd > /dev/null
-  echo "<<< fetch_x_api()"
+  echo "<<< make_local_trackler()"
 }
 
 start_x_api() {
-  echo ">>> start_x_api(\"$1\")"
-  local XAPI_HOME="$1"
+  local xapi_home="$1"
+  echo ">>> start_x_api(xapi_home=\"${xapi_home}\")"
 
-  pushd $XAPI_HOME >/dev/null
+  pushd $xapi_home
 
-  SET_RUBY_VER_CMD="rbenv local 2.2.1"
   gem install bundler
   bundle install
-
   RACK_ENV=development rackup &
-  XAPI_PID=$!
+  xapi_pid=$!
   sleep 5
 
-  echo "X-API is running (pid=${XAPI_PID})."
+  echo "x-api is running (pid=${xapi_pid})."
 
   popd > /dev/null
   echo "<<< start_x_api()"
 }
 
 configure_exercism_cli() {
-  echo ">>> configure_exercism_cli(\"$1\", \"$2\", $3)"
-  local EXERCISM_HOME="$1"
-  local EXERCISM_CONFIGFILE="$2"
-  local XAPI_PORT=$3
-  local EXERCISM="./exercism --config ${EXERCISM_CONFIGFILE}"
-
-  mkdir -p "${EXERCISM_HOME}"
-  pushd "${EXERCISM_HOME}" >/dev/null
-  $EXERCISM configure --dir="${EXERCISM_HOME}"
-  $EXERCISM configure --api http://localhost:${XAPI_PORT}
-  $EXERCISM debug
-  popd >/dev/null
+  local exercism_home="$1"
+  local exercism_configfile="$2"
+  local xapi_port=$3
+  echo ">>> configure_exercism_cli(exercism_home=\"${exercism_home}\", exercism_configfile=\"${exercism_configfile}\", xapi_port=${xapi_port})"
+  local exercism="./exercism --config ${exercism_configfile}"
+
+  mkdir -p "${exercism_home}"
+  pushd "${exercism_home}"
+  $exercism configure --dir="${exercism_home}"
+  $exercism configure --api http://localhost:${xapi_port}
+  $exercism debug
+  popd
 
   echo "<<< configure_exercism_cli()"
 }
 
 solve_all_exercises() {
-  echo ">>> solve_all_exercises(\"$1\", \"$2\")"
-
-  local EXERCISM_HOME="$1"
-  local EXERCISM_CONFIGFILE="$2"
-
-  local EXERCISM="./exercism --config ${EXERCISM_CONFIGFILE}"
-  local EXERCISES=`cat config.json | jq '.problems []' --raw-output`
-  local TOTAL_EXERCISES=`cat config.json | jq '.problems | length'`
-  local CURRENT_EXERCISE_NUMBER=1
-  local TEMPFILE="${TMPDIR:-/tmp}/journey-test.sh-unignore_all_tests.txt"
-
-  pushd ${EXERCISM_HOME} >/dev/null
-  for EXERCISE in $EXERCISES; do
-    echo ''
-    echo '****' Testing $EXERCISE '('$CURRENT_EXERCISE_NUMBER / $TOTAL_EXERCISES') ****'
-    echo ''
-    $EXERCISM fetch java $EXERCISE
-    cp -R -H $REPO_ROOT/exercises/$EXERCISE/src/example/java/* $EXERCISM_HOME/java/$EXERCISE/src/main/java/
-    pushd $EXERCISM_HOME/java/$EXERCISE/ >/dev/null
-    for TESTFILE in `find . -name "*Test.java"`; do
-      sed 's/@Ignore//' $TESTFILE > "$TEMPFILE" && mv "$TEMPFILE" "$TESTFILE"
+  local exercism_exercises_dir="$1"
+  local exercism_configfile="$2"
+  echo ">>> solve_all_exercises(exercism_exercises_dir=\"${exercism_exercises_dir}\", exercism_configfile=\"${exercism_configfile}\")"
+
+  local xjava=$( pwd )
+  local exercism_cli="./exercism --config ${exercism_configfile}"
+  local exercises=`cat config.json | jq '.problems []' --raw-output`
+  local total_exercises=`cat config.json | jq '.problems | length'`
+  local current_exercise_number=1
+  local tempfile="${TMPDIR:-/tmp}/journey-test.sh-unignore_all_tests.txt"
+
+  pushd ${exercism_exercises_dir}
+  for exercise in $exercises; do
+    echo -e "\n\n"
+    echo "=================================================="
+    echo "${current_exercise_number} of ${total_exercises} -- ${exercise}"
+    echo "=================================================="
+
+    ${exercism_cli} fetch java $exercise
+    cp -R -H ${xjava}/exercises/${exercise}/src/example/java/* ${exercism_exercises_dir}/java/${exercise}/src/main/java/
+
+    pushd ${exercism_exercises_dir}/java/${exercise}
+    # Ensure we run all the tests (as delivered, all but the first is @Ignore'd)
+    for testfile in `find . -name "*Test.java"`; do
+      sed 's/@Ignore//' ${testfile} > "${tempfile}" && mv "${tempfile}" "${testfile}"
     done
     gradle test
-    popd >/dev/null
+    popd
 
-    CURRENT_EXERCISE_NUMBER=$((CURRENT_EXERCISE_NUMBER + 1))
+    current_exercise_number=$((current_exercise_number + 1))
   done
-  popd >/dev/null
+  popd
 }
 
 main() {
-  # allow all functions to assume current working directory is repository root.
+  # all functions assume current working directory is repository root.
   cd "${SCRIPTPATH}/.."
 
-  local REPO_ROOT="${PWD}"
-  local BUILD_DIR="${REPO_ROOT}/build"
-  local XAPI_HOME="${BUILD_DIR}/x-api"
-  local EXERCISM_HOME="${BUILD_DIR}/exercism"
-  local EXERCISM_CONFIGFILE=".journey-test.exercism.json"
-  local XAPI_PORT=9292
-
-  assert_gradle_installed
-  assert_jq_installed
-  clean_build "${REPO_ROOT}" "${BUILD_DIR}"
-  fetch_exercism_cli $(get_operating_system) $(get_cpu_architecture) "${EXERCISM_HOME}"
-  fetch_x_api "${XAPI_HOME}"
-  assert_required_ruby_installed "${XAPI_HOME}"
-  start_x_api "${XAPI_HOME}"
-  configure_exercism_cli "${EXERCISM_HOME}" "${EXERCISM_CONFIGFILE}" "${XAPI_PORT}"
-  solve_all_exercises "${EXERCISM_HOME}" "${EXERCISM_CONFIGFILE}"
+  local xjava=$( pwd )
+  local build_dir="build"
+  local build_path="${xjava}/${build_dir}"
+
+  local xapi_home="${build_path}/x-api"
+  local trackler_home="${build_path}/trackler"
+  local exercism_home="${build_path}/exercism"
+
+  local exercism_configfile=".journey-test.exercism.json"
+  local xapi_port=9292
+
+  # fail fast if required binaries are not installed.
+  assert_installed "gradle"
+  assert_installed "jq"
+
+  clean "${build_dir}"
+
+  # Make a version of trackler that includes the source from this repo.
+  git_clone "trackler" "${trackler_home}"
+  assert_ruby_installed "${trackler_home}"
+  make_local_trackler "${trackler_home}"
+
+  # Stand-up a local instance of x-api so we can fetch the exercises through it.
+  git_clone "x-api" "${xapi_home}"
+  assert_ruby_installed "${xapi_home}"
+  start_x_api "${xapi_home}"
+
+  # Create a CLI install and config just for this build; this script does not use your CLI install.
+  download_exercism_cli $(get_operating_system) $(get_cpu_architecture) "${exercism_home}"
+  configure_exercism_cli "${exercism_home}" "${exercism_configfile}" "${xapi_port}"
+
+  solve_all_exercises "${exercism_home}" "${exercism_configfile}"
 }
 
 ##########################################################################
 # Execution begins here...
 
+# If any command fails, fail the script.
 set -e
+SCRIPTPATH=$( pushd `dirname $0` > /dev/null && pwd && popd > /dev/null )
+EXECPATH=$( pwd )
+# Make output easier to read in CI
+TERM=dumb
+
+xapi_pid=""
 trap on_exit EXIT
 main
 

data/tracks/java/docs/ABOUT.md

@@ -18,15 +18,12 @@ The language derives much of its syntax from C and C++, but it has fewer low-lev
 
 ## Why Learn JAVA?
 
-- JAVA IS EVERYWHERE. It is one of the most sought after programming languages, as it is a standard for enterprise software, web-based content, games and mobile apps, as well as the [Android operating system](https://developer.android.com/index.html). 
-
-- [Write once, run anywhere](https://en.wikipedia.org/wiki/Write_once,_run_anywhere) policy : Programs written in Java, are compiled into machine-independent bytecodes, so it can run on any Java platform.Basically, Java is [Platform Independent](https://en.wikipedia.org/wiki/Cross-platform#Platform-independent_software)
-
-- Java has a Rich API:
-Java provides [API](https://en.wikipedia.org/wiki/Application_programming_interface)'s(Application Programming Interface) for I/O, networking, utilities, XML parsing, database connections, and many other functions. Standard libraries can be supplemented by open source libraries like Apache Commons, Google Guava and others.
+- JAVA IS EVERYWHERE. It is one of the most sought after programming languages. It is a standard for enterprise software, web-based content, games and mobile apps, as well as the [Android operating system](https://developer.android.com/index.html). 
 
+- [Write once, run anywhere](https://en.wikipedia.org/wiki/Write_once,_run_anywhere) policy: Programs written in Java are compiled into machine-independent bytecodes, so it can run on any Java platform. Basically, Java is [Platform Independent](https://en.wikipedia.org/wiki/Cross-platform#Platform-independent_software)
 
+- Java has rich APIs:
+Java has built-in [application programming interfaces](https://en.wikipedia.org/wiki/Application_programming_interface) (APIs) for I/O, networking, data structures, concurrency, and many other functions. Standard libraries can be supplemented by open source libraries like Apache Commons, Google Guava, Netty and others.
 
 - Standardization:
-If you need to write a web/enterprise app, or you need data persistence or you need to do cryptography, no problem! Java is all you require.There are several other standardized stuff in the Java ecosystem, thanks to the [JCP](https://www.jcp.org/en/introduction/overview) (Java Community Process)!
-
+If you need to write a web/enterprise app, or you need data persistence or you need to do cryptography, no problem! Java is all you require. There are many standard tools/practices that extend the Java ecosystem, thanks to the [Java Community Process](https://www.jcp.org/en/introduction/overview) (JCP)!

data/tracks/java/exercises/hello-world/build.gradle

@@ -16,9 +16,3 @@ test {
     events = ["passed", "failed", "skipped"]
   }
 }
-test {
-  testLogging {
-    exceptionFormat = 'full'
-    events = ["passed", "failed", "skipped"]
-  }
-}

data/tracks/java/exercises/hello-world/src/test/java/HelloWorldTest.java

@@ -1,6 +1,5 @@
 import org.junit.Test;
 import org.junit.Ignore;
-import org.junit.Ignore;
 
 import static org.junit.Assert.assertEquals;
 

data/tracks/java/exercises/meetup/build.gradle

@@ -7,7 +7,6 @@ repositories {
 }
 
 dependencies {
-  compile "joda-time:joda-time:2.3+"
   testCompile "junit:junit:4.10"
   testCompile "org.assertj:assertj-core:3.2.0"
 }