Multi Cloud Developer Tools

Source:
http://www.developereconomics.com/4-2-tools-happy-multi-cloud-developer/


http://jclouds.apache.org/

https://deltacloud.apache.org/

Flow Based Programming

http://www.jpaulmorrison.com/fbp/


JavaFBP
https://github.com/jpaulm/javafbp
https://github.com/flowbased/flowbased.org/wiki

Payment Gateway

Paypal

https://developer.paypal.com/webapps/developer/index

Running single app on mobile devices

Apple
Accessibility, Guide Access
http://support.apple.com/kb/ht5509


Android
https://play.google.com/store/apps/details?id=com.gears42.surelock
http://www.gakshay.com/2013/01/14/run-android-as-kiosk-or-single-application-mode/
http://stackoverflow.com/questions/4081264/is-it-possible-to-configure-an-android-install-to-run-a-single-app/4081326#4081326

Mobile Backend as a Service

Mobile Backend-as-a-Service Providers(MBaaS) - Close Source

1. Appcelerator Cloud [http://www.appcelerator.com/cloud/]
2. Parse [https://www.parse.com/]
3. Kinvey [http://www.kinvey.com/]
4. StackMob [https://www.stackmob.com/]
5. Applicasa [http://www.applicasa.com/]
6. Anypresence [http://www.anypresence.com/]
7. Appacitive [http://appacitive.com/]
8. Cloudmine [https://cloudmine.me/]
9. Scottyapp [http://scottyapp.com/]
10. API-O-Mat [http://www.apiomat.com/]
11. APP42 CloudAPI [http://api.shephertz.com/]
12. Kii [http://www.kii.com/en/technology/kiicloud]
13. Kumulos [http://www.kumulos.com/]
14. Feedhenry [http://www.feedhenry.com/]
15. API Engine [https://apiengine.io/features]
16. Quickblox [http://quickblox.com/]

Mobile Backend-as-a-Service Providers(MBaaS) - Open Source

1. OpenMobster [http://www.openmobster.com/showcase.html]
2. OpenKit [http://openkit.io/]
3. BaasBox [http://www.baasbox.com/]
4. Helios [http://helios.io/]
5. LiveOak [http://liveoak.io/]

source:

http://www.kpbird.com/2013/05/list-of-mobile-backend-as-service.html

Mobile Enterprise Application Platform

http://www.openmeap.com/

http://www.convertigo.com/
http://sourceforge.net/projects/convertigo/

https://code.google.com/p/openmobster/

http://www.dreamfactory.com/

https://www.modolabs.com/platform

http://en.wikipedia.org/wiki/Mobile_enterprise_application_platform
http://www.slideshare.net/goldengekko/gg-marketing-finder-become-a-mobile-enterprise-rock-star-p3

Error Tracking Tool for Java

http://www.takipiblog.com/5-error-tracking-tools-java-developers-should-know/#more-580

Large Dataset

http://www.quora.com/Where-can-I-find-large-datasets-open-to-the-public

SQL Penetration Test Tool

http://sqlmap.org/

Netbeans Platform Internationalization Settings

http://ditoinfo.wordpress.com/2007/02/26/netbeans-and-utf8-encoding-2/
netbeans_default_options:
-J-Dfile.encoding=UTF-8


https://blogs.oracle.com/tao/entry/set_netbeans_user_interface_language
-J-Duser.language=en -J-Duser.region=US

-J-Duser.language=ja -J-Duser.region=JP

Windows support for hard disks that are larger than 2 TB

http://support.microsoft.com/kb/2581408

Big Data Sets

source
http://www.quora.com/Where-can-I-find-large-datasets-open-to-the-public



Cross-disciplinary data repositories, data collections and data search engines:

• http://usgovxml.com
• http://aws.amazon.com/datasets
• http://databib.org
• http://datacite.org
• http://figshare.com
• http://linkeddata.org
• http://reddit.com/r/datasets
• http://thedatahub.org alias http://ckan.net
• http://quandl.com
• Social Network Analysis Interactive Dataset Library (Social Network Datasets)
• Datasets for Data Mining
• http://enigma.io

Single datasets and data repositories

http://archive.ics.uci.edu/ml/
http://crawdad.org/
http://data.austintexas.gov
http://data.cityofchicago.org
http://data.govloop.com
http://data.gov.uk/
data.gov.in
http://data.medicare.gov
http://data.seattle.gov
http://data.sfgov.org
http://data.sunlightlabs.com
https://datamarket.azure.com/
http://developer.yahoo.com/geo/g...
http://econ.worldbank.org/datasets
http://en.wikipedia.org/wiki/Wik...
http://factfinder.census.gov/ser...
http://ftp.ncbi.nih.gov/
http://gettingpastgo.socrata.com
http://googleresearch.blogspot.c...
http://books.google.com/ngrams/
http://medihal.archives-ouvertes.fr
http://public.resource.org/
http://rechercheisidore.fr
http://snap.stanford.edu/data/in...
http://timetric.com/public-data/
https://wist.echo.nasa.gov/~wist...
http://www2.jpl.nasa.gov/srtm
http://www.archives.gov/research...
http://www.bls.gov/
http://www.crunchbase.com/
http://www.dartmouthatlas.org/
http://www.data.gov/
http://www.datakc.org
http://dbpedia.org
http://www.delicious.com/jbaldwi...
http://www.faa.gov/data_research/
http://www.factual.com/
http://research.stlouisfed.org/f... 
http://www.freebase.com/
http://www.google.com/publicdata...
http://www.guardian.co.uk/news/d...
http://www.infochimps.com
http://www.kaggle.com/
http://build.kiva.org/
http://www.nationalarchives.gov....
http://www.nyc.gov/html/datamine...
http://www.ordnancesurvey.co.uk/...
http://www.philwhln.com/how-to-g...
http://www.imdb.com/interfaces
http://imat-relpred.yandex.ru/en...
http://www.dados.gov.pt/pt/catal...
http://knoema.com
http://daten.berlin.de/
http://www.qunb.com
http://databib.org/
http://datacite.org/
http://data.reegle.info/
http://data.wien.gv.at/
http://data.gov.bc.ca
https://pslcdatashop.web.cmu.edu/ (interaction data in learning environments)
http://www.icpsr.umich.edu/icpsrweb/CPES/ - Collaborative Psychiatric Epidemiology Surveys: (A collection of three national surveys focused on each of the major ethnic groups to study psychiatric illnesses and health services use)
http://www.dati.gov.it
http://dati.trentino.it

Mobile cloud sync

http://sourceforge.net/projects/funambol/files/bundle/v10/

http://www.openmobster.com

Html5 data sync: offline online

http://www.ibm.com/developerworks/library/wa-html5db/index.html
https://github.com/orbitaloop/WebSqlSync

http://www.j-io.org
http://diveintohtml5.info/storage.html
http://www.deardorffdigital.com/articles/html5-web-storage
http://www.html5rocks.com/en/features/storage
https://github.com/coresmart/persistencejs

http://blog.oxfordcc.co.uk/backbone-local-storage-and-server-synchronization/

Java Sync Framework

http://www.symmetricds.org/about/overview

http://www.manageability.org/blog/stuff/java-open-source-replication-synchronization/view

Compare Image

http://stackoverflow.com/questions/1460239/library-that-identifies-similar-images

http://www.pureftpd.org/project/libpuzzle
http://appsrv.cse.cuhk.edu.hk/~jkzhu/felib.html


http://mindmeat.blogspot.sg/2008/11/java-image-comparison.html
http://mindmeat.blogspot.sg/2008/07/java-image-comparison.html


http://www.lac.inpe.br/JIPCookbook/6050-howto-compareimages.jsp#howtohowdoicomparetwoimagestoseeiftheyareequalaverysimplealgorithmtocompareimagesforipossibleisimilaritywithoutconsideringthehighlevelcontents

html5 form validation

http://ericleads.com/h5validate/

http://parsleyjs.org

Zorba: NoSQL Query Processing

http://www.zorba.io/home

Dynamic Reporting

http://www.developer.com/java/doing-dynamic-reporting-through-jasperreport.html?dni=144043881&rni=7219120

http://dynamicjasper.com/project-info/

How to set TransformerFactory

http://stackoverflow.com/questions/11314604/how-to-set-saxon-as-the-xslt-processor-in-java

NB Classloader

http://bits.netbeans.org/dev/javadoc/org-openide-modules/org/openide/modules/doc-files/classpath.html#syscl

XMLBeans compiling with schema dependencies

 http://wiki.apache.org/xmlbeans/XmlBeansFaq#schemaDependencies

Issue with JavaMail connection permission disallowed due to JDK 7

http://stackoverflow.com/questions/7477712/sending-email-using-jsp/7478027#7478027

https://www.java.net/node/703177


-Djava.net.preferIPv4Stack=true

Java Design Patterns

http://www.tutorialspoint.com/design_pattern/index.htm

Android Tutorial

android-hello-world-example-how-to-develop-android-apps.html

android-studio-getting-started-with-the-new-android-ide.html

http://examples.javacodegeeks.com/android/core/android-debugging-on-a-real-device/

http://www.javacodegeeks.com/2010/10/android-full-application-tutorial.html

http://www.javacodegeeks.com/2011/06/android-game-development-tutorials.html

http://examples.javacodegeeks.com/android/core/build-android-application-package-file-apk-using-eclipse-ide/

http://examples.javacodegeeks.com/android/core/provider/android-contacts-example/

http://examples.javacodegeeks.com/android/core/content/broadcastreceiver/android-broadcast-receivers-example/

http://examples.javacodegeeks.com/android/core/content/contentprovider/android-content-provider-example/

http://www.javacodegeeks.com/2013/09/android-app-developmentweather-app-with-forecast.html

Searching in PDF and other file formats

http://tika.apache.org/

http://www.programming-free.com/2012/11/simple-word-search-in-pdf-files-using.html

http://www.blog.computergodzilla.com/2012/12/apache-lucene-how-to-index-doc-pdf-and.html

http://www.blog.computergodzilla.com/2012/12/apache-lucene-how-to-parse-texts-from_30.html

http://kalanir.blogspot.sg/2008/07/extracting-text-from-xml-documents-for.html

Netbeans Platform with FX

http://netbeans.dzone.com/javafx-2-in-netbeans-rcp


http://www.aljoscha-rittner.de/blog/archive/2011/03/04/javafxdev-netbeans-platform-with-javafx-2-0ea/

Apache Lucene: TableSearcher.java (updated for Lucene v4.8)

TableSearcher.java


/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package javaapplication3;

/**
 * Copyright 2005 The Apache Software Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
import org.apache.lucene.analysis.Analyzer;
//import org.apache.lucene.analysis.WhitespaceAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.queryparser.classic.MultiFieldQueryParser;
//import org.apache.lucene.search.Hits;
import org.apache.lucene.search.IndexSearcher;
import org.apache.lucene.search.Query;
import org.apache.lucene.store.RAMDirectory;

import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableModel;
import java.util.ArrayList;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.IndexWriterConfig.OpenMode;
import org.apache.lucene.search.ScoreDoc;
import org.apache.lucene.search.TopDocs;
import org.apache.lucene.util.Version;

/**
 * This is a TableModel that encapsulates Lucene search logic within a
 * TableModel implementation. It is implemented as a TableModel decorator,
 * similar to the TableSorter demo from Sun that decorates a TableModel and
 * provides sorting functionality. The benefit of this architecture is that you
 * can decorate any TableModel implementation with this searching table model --
 * making it easy to add searching functionaliy to existing JTables -- or making
 * new search capable table lucene.
 *
 *
 * This decorator works by holding a reference to a decorated ot inner
 * TableModel. All data is stored within that table model, not this table model.
 * Rather, this table model simply manages links to data in the inner table
 * model according to the search. All methods on TableSearcher forward to the
 * inner table model with subtle filtering or alteration according to the search
 * criteria.
 *
 *
 * Using the table model:
 *
 * Pass the TableModel you want to decorate in at the constructor. When the
 * TableModel initializes, it displays all search results. Call the search
 * method with any valid Lucene search String and the data will be filtered by
 * the search string. Users can always clear the search at any time by searching
 * with an empty string. Additionally, you can add a button calling the
 * clearSearch() method.
 *
 */
public class TableSearcher extends AbstractTableModel {

    /**
     * The inner table model we are decorating
     */
    protected TableModel tableModel;

    /**
     * This listener is used to register this class as a listener to the
     * decorated table model for update events
     */
    private TableModelListener tableModelListener;

    /**
     * these keeps reference to the decorated table model for data only rows
     * that match the search criteria are linked
     */
    private ArrayList rowToModelIndex = new ArrayList();

    //Lucene stuff.
    /**
     * In memory lucene index
     */
    private RAMDirectory directory;

    /**
     * Cached lucene analyzer
     */
    private Analyzer analyzer;

    /**
     * Links between this table model and the decorated table model are
     * maintained through links based on row number. This is a key constant to
     * denote "row number" for indexing
     */
    private static final String ROW_NUMBER = "ROW_NUMBER";

    /**
     * Cache the current search String. Also used internally to key whether
     * there is an active search running or not. i.e. if searchString is null,
     * there is no active search.
     */
    private String searchString = null;
   
   

    /**
     * @param tableModel The table model to decorate
     */
    public TableSearcher(TableModel tableModel) {
//        analyzer = new WhitespaceAnalyzer();
        analyzer = new StandardAnalyzer(Version.LUCENE_48);
        tableModelListener = new TableModelHandler();
        setTableModel(tableModel);
        tableModel.addTableModelListener(tableModelListener);
        clearSearchingState();
    }

    /**
     *
     * @return The inner table model this table model is decorating
     */
    public TableModel getTableModel() {
        return tableModel;
    }

    /**
     * Set the table model used by this table model
     *
     * @param tableModel The new table model to decorate
     */
    public void setTableModel(TableModel tableModel) {

        //remove listeners if there...
        if (this.tableModel != null) {
            this.tableModel.removeTableModelListener(tableModelListener);
        }

        this.tableModel = tableModel;
        if (this.tableModel != null) {
            this.tableModel.addTableModelListener(tableModelListener);
        }

        //recalculate the links between this table model and
        //the inner table model since the decorated model just changed
        reindex();

        // let all listeners know the table has changed
        fireTableStructureChanged();
    }

    /**
     * Reset the search results and links to the decorated (inner) table model
     * from this table model.
     */
    private void reindex() {
        try {
            // recreate the RAMDirectory
            directory = new RAMDirectory();
            Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_48);
            IndexWriterConfig iwc = new IndexWriterConfig(Version.LUCENE_48, analyzer);
            boolean create = true;
            if (create) {
                // Create a new index in the directory, removing any
                // previously indexed documents:
                iwc.setOpenMode(OpenMode.CREATE);
            } else {
                // Add new documents to an existing index:
                iwc.setOpenMode(OpenMode.CREATE_OR_APPEND);
            }

            // Optional: for better indexing performance, if you
            // are indexing many documents, increase the RAM
            // buffer.  But if you do this, increase the max heap
            // size to the JVM (eg add -Xmx512m or -Xmx1g):
            //
            // iwc.setRAMBufferSizeMB(256.0);
            IndexWriter writer = new IndexWriter(directory, iwc);
//            indexDocs(writer, docDir);
            // iterate through all rows
            for (int row = 0; row < tableModel.getRowCount(); row++) {

                //for each row make a new document
                Document document = new Document();
                //add the row number of this row in the decorated table model
                //this will allow us to retrive the results later
                //and map this table model's row to a row in the decorated
                //table model
                document.add(new Field(ROW_NUMBER, "" + row, Field.Store.YES, Field.Index.ANALYZED));
                //iterate through all columns
                //index the value keyed by the column name
                //NOTE: there could be a problem with using column names with spaces
                for (int column = 0; column < tableModel.getColumnCount(); column++) {
                    String columnName = tableModel.getColumnName(column);
                    String columnValue = String.valueOf(tableModel.getValueAt(row, column)).toLowerCase();
                    document.add(new Field(columnName, columnValue, Field.Store.YES, Field.Index.ANALYZED));
                }
                writer.addDocument(document);
            }
//            writer.optimize();
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * @return The current lucene analyzer
     */
    public Analyzer getAnalyzer() {
        return analyzer;
    }

    /**
     * @param analyzer The new analyzer to use
     */
    public void setAnalyzer(Analyzer analyzer) {
        this.analyzer = analyzer;
        //reindex from the model with the new analyzer
        reindex();

        //rerun the search if there is an active search
        if (isSearching()) {
            search(searchString);
        }
    }

    /**
     * Run a new search.
     *
     * @param searchString Any valid lucene search string
     */
    public void search(String searchString) {

        //if search string is null or empty, clear the search == search all
        if (searchString == null || searchString.equals("")) {
            clearSearchingState();
            fireTableDataChanged();
            return;
        }

        try {
            //cache search String
            this.searchString = searchString;
//            String index = "";
//            IndexReader reader = DirectoryReader.open(FSDirectory.open(new File(index)));
//            IndexSearcher is = new IndexSearcher(reader);
            // :Post-Release-Update-Version.LUCENE_XY:
//            Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_48);

            IndexReader reader = IndexReader.open(directory);
            //make a new index searcher with the in memory (RAM) index.I
            IndexSearcher is = new IndexSearcher(reader);

            //make an array of fields - one for each column
            String[] fields = new String[tableModel.getColumnCount()];
            for (int t = 0; t < tableModel.getColumnCount(); t++) {
                fields[t] = tableModel.getColumnName(t);
            }

            //build a query based on the fields, searchString and cached analyzer
            //NOTE: This is an area for improvement since the MultiFieldQueryParser
            // has some weirdness.
            MultiFieldQueryParser parser = new MultiFieldQueryParser(Version.LUCENE_36, fields, analyzer);
            Query query = parser.parse(searchString);
            //run the search
            TopDocs hits = is.search(query, 10);
            //reset this table model with the new results
            resetSearchResults(hits);
        } catch (Exception e) {
            e.printStackTrace();
        }

        //notify all listeners that the table has been changed
        fireTableStructureChanged();
    }

    /**
     *
     * @param hits The new result set to set this table to.
     */
    private void resetSearchResults(TopDocs hits) {
        try {
            //clear our index mapping this table model rows to
            //the decorated inner table model
            rowToModelIndex.clear();
            //iterate through the hits
            //get the row number stored at the index
            //that number is the row number of the decorated
            //tabble model row that we are mapping to
            for (int t = 0; t < hits.totalHits; t++) {
                ScoreDoc document = hits.scoreDocs[t];
                rowToModelIndex.add(document.doc);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private int getModelRow(int row) {
        return ((Integer) rowToModelIndex.get(row)).intValue();
    }

    /**
     * Clear the currently active search Resets the complete dataset of the
     * decorated table model.
     */
    private void clearSearchingState() {
        searchString = null;
        rowToModelIndex.clear();
        for (int t = 0; t < tableModel.getRowCount(); t++) {
            rowToModelIndex.add(new Integer(t));
        }
    }

    // TableModel interface methods
    public int getRowCount() {
        return (tableModel == null) ? 0 : rowToModelIndex.size();
    }

    public int getColumnCount() {
        return (tableModel == null) ? 0 : tableModel.getColumnCount();
    }

    public String getColumnName(int column) {
        return tableModel.getColumnName(column);
    }

    public Class getColumnClass(int column) {
        return tableModel.getColumnClass(column);
    }

    public boolean isCellEditable(int row, int column) {
        return tableModel.isCellEditable(getModelRow(row), column);
    }

    public Object getValueAt(int row, int column) {
        return tableModel.getValueAt(getModelRow(row), column);
    }

    public void setValueAt(Object aValue, int row, int column) {
        tableModel.setValueAt(aValue, getModelRow(row), column);
    }

    private boolean isSearching() {
        return searchString != null;
    }

    private class TableModelHandler implements TableModelListener {

        public void tableChanged(TableModelEvent e) {
            // If we're not searching, just pass the event along.
            if (!isSearching()) {
                clearSearchingState();
                reindex();
                fireTableChanged(e);
                return;
            }

            // Something has happened to the data that may have invalidated the search.
            reindex();
            search(searchString);
            fireTableDataChanged();
            return;
        }

    }

}