Machine Learning’s ‘Amazing’ Ability to Predict Chaos

Machine Learning’s ‘Amazing’ Ability to Predict Chaos
http://go.squidapp.co/n/eSFPx8E

Download SQUID – Your News Buddy
squidapp.co/getSQUID

So, you want to build a bot with NodeJs?

    I have used Node.js in a number of projects and in conjunction with the module bundler called Webpack  and the automation toolkit Gulp, but still I wanted to experiment with something different that would bring up the advantages of using such a server-side platform. I remembered that the Microsoft Bot Framework employs Node.js for its Bot Builder SDK and why not building bots sounds interesting! I have actually found out that there are a few books specifically focusing on building bots with Node.js and that seemed to be like a fun task. The choice then became clear, let’s use Node.js and Twit, a Twitter API Client for Node, to build a Twitter bot that simply sends a query to the Twitter API, receives a response containing the results of the performed search, and then retweets the most recent tweet returned. Let’s see what we need to achieve this!

    Set up a dedicated Twitter account for your Bot

    Bots get usually banned from Twitter, so it is recommended to create Twitter account perhaps with a secondary email address specifically for the following experiment. It is highly recommended that you do not use your “official” Twitter account as it is likely that it will be short-lived.  After your new account is activated, go to the Twitter Developer Center and sign in with your new details. You might also want to have a look around and in particular have a read through the documentation on how to get started with the Twitter Developer Platform and how to create your first app.

    Screen Shot 2018-03-07 at 23.05.45.png

    Create a Twitter App

    From your acccount, you will be able to see the newly created app from here.   After creating the application, look for ‘Keys and Access Tokens’ and click on ‘Generate Token Actions’. Make a copy of the details below as you will be using them later as part of your

    • Consumer Key
    • Consumer Secret
    • Access Token
    • Access Token Secret

    The Part where you code

    You will interact with your newly created Twitter App via a Nodejs library called Twit. Create a new project folder in your Dev directory (ideally the directory structure where your git installation resides):

     

    This will kick off an utility that will take you through the process of creating the package.json file.

     

    Then you will need to install Twit, the Twitter API Client for Node that supports REST and Streaming API.

    and create a file called

    This will be your main application file, that means the entry point of your app. You will also need a third and additional file called

    where you will past the following:

    • Consumer Key
    • Consumer Secret
    • Access Token
    • Access Token Secret

    It will look like this:

     

     

    Your directory structure should look as follows:

     

     

    The part where you make the Bot do something

    Next step is to make your bot to query the most recent tweets. We will need to write a function that finds the latest tweets according to the query passed as a parameter. To do so, we need to initialise a params object holding aq property that will refine our searches. In our case, we are targeting tweets with hashtag #nodejs and #Nodejs:

     

     

    the property

    instructs the bot to search exclusively for the tweets that were posted since the bot was started. We can use

    , which accepts three arguments: API endpoint, params object (defined by us) and a callback.

     

    To post or to retweet the tweet the bot has found, we have used the Twitter.post() method to post to any of the REST API endpoints.

    Usage

    In order to run your bot, you should simply type the following command on terminal:

    Alternatively, it is possible to use:

    in a nutshell, they are scripts whose goal is to automate repetitive tasks. This requires to modify the file

    by adding the following lines of code:

     

    and then you can type

    An Oracle JDBC Client

    A while ago I was tasked to write a small application in order to connect to an Oracle Database and perform a set of simple queries. For such a task, I have employed the DAO (Data Access Object) pattern and a corresponding DAO Interface. A basic Java client, in turn, calls the instantiation of such DAO class, which implements a the DAO interface. As follow, the application in its internal details:

    Oracle DB Client 

    [code language=”java”]
    package oracledb.connection.client;
    import oracledb.connection.dao.OracleDB_DAO;

    public class OracleConnectionClient {

    public static void main(String[] args) throws Exception {

    OracleDB_DAO dao = new OracleDB_DAO();
    dao.readPropertiesFile();
    dao.openConnection();
    dao.getDBCurrentTime();
    dao.getFirstNameAndLastNameFromCustomers();
    dao.closeConnection();

    }
    }
    [/code]
    The Data Access Object (DAO) implementation. The method[code]readPropertiesFile()[/code]

    parses a properties file containing the access credentials and DB connection details.

     

    [code language=”java”]
    package oracledb.connection.dao;

    import java.io.*;
    import java.sql.*;
    import java.util.Properties;

    public class OracleDB_DAO implements OracleDB_DAO_Interface {

    public static String SAMPLE_SELECT_QUERY = “SELECT * FROM CUSTOMERS WHERE FirstName = ‘Eliott’ AND LastName = ‘Brown'”;

    private static String driverClass = “oracle.jdbc.driver.OracleDriver”;
    private Connection connection;
    private static String dbUrl;
    private static String userName;
    private static String password;

    static String resourceName = “dbconnection.properties”;

    /**
    * Read the properties Initialise the DAO
    *
    * @throws IOException
    * @throws ClassNotFoundException
    */

    public void readPropertiesFile() throws IOException, ClassNotFoundException {

    ClassLoader loader = Thread.currentThread().getContextClassLoader();
    Properties props = new Properties();
    InputStream resourceStream = loader.getResourceAsStream(resourceName);
    {
    props.load(resourceStream);
    }

    // Return the properties
    dbUrl = props.getProperty(“dburl”);
    userName = props.getProperty(“dbuser”);
    password = props.getProperty(“dbpassword”);

    // Load the
    Class.forName(driverClass);
    }

    /*
    * (non-Javadoc)
    *
    * @see oracledb.connection.dao.OracleDB_DAO_Interface1#openConnection()
    */
    @Override
    public void openConnection() throws SQLException {

    // get the connection to the database
    System.out.println(“Establishing the Connection to the Database”);
    try {
    connection = DriverManager.getConnection(dbUrl, userName, password);
    System.out.println(connection);
    } catch (SQLException ex) {
    ex.printStackTrace();
    }
    }

    /*
    * (non-Javadoc)
    *
    * @see oracledb.connection.dao.OracleDB_DAO_Interface1#closeConnection()
    */
    @Override
    public void closeConnection() throws SQLException {
    if (connection != null) {
    // close the connection
    connection.close();
    }
    }

    /*
    * (non-Javadoc)
    *
    * @see oracledb.connection.dao.OracleDB_DAO_Interface1#
    * getFirstNameAndLastNameFromCustomers()
    */
    @Override
    @SuppressWarnings(“resource”)
    public ResultSet getFirstNameAndLastNameFromCustomers() throws SQLException, IOException {
    // create the prepared stmt
    Statement stmt = connection.createStatement();
    // assign the query to a variable
    String sql = SAMPLE_SELECT_QUERY;
    // execute the query
    ResultSet rs = stmt.executeQuery(sql);
    System.out.println(“This print the ResultSet for getPlanByMSISD ” + rs);
    @SuppressWarnings(“unused”)
    PrintWriter csvWriter = new PrintWriter(new File(“sample.csv”));

    stmt.close(); // close statement
    return rs;
    }

    /*
    * (non-Javadoc)
    *
    * @see oracledb.connection.dao.OracleDB_DAO_Interface1#getDBCurrentTime()
    */
    @Override
    public String getDBCurrentTime() throws SQLException, IOException {
    String dateTime = null;
    // create the prepared stmt
    Statement stmt = connection.createStatement();
    ResultSet rst = stmt.executeQuery(“select SYSDATE from dual”);
    while (rst.next()) {
    dateTime = rst.getString(1);
    }
    // close the resultset
    System.out.println(“This prints the dateTime from the DB ” + dateTime);
    rst.close();
    return dateTime;

    }
    }
    [/code]
    The DAO Interface that defines the standard operations to be performed on a model object:

    [code language=”java”]
    package oracledb.connection.dao;

    import java.io.IOException;
    import java.sql.ResultSet;
    import java.sql.SQLException;

    public interface OracleDB_DAO_Interface {

    /**
    * Open the Dao Connection
    *
    * @param
    * @throws SQLException
    * @throws IOException
    */
    void openConnection() throws SQLException;

    /**
    * Close the connection
    *
    * @throws SQLException
    */
    void closeConnection() throws SQLException;

    /**
    * Get the resultset from the the select query
    *
    * @throws SQLException
    * @throws IOException
    */
    ResultSet getFirstNameAndLastNameFromCustomers() throws SQLException, IOException;

    /**
    * Get the Current Time via DB Query
    *
    * @return
    * @throws SQLException
    * @throws IOException
    */
    String getDBCurrentTime() throws SQLException, IOException;

    }
    [/code]

    12+ must have Atom packages to work in JavaScript | Void Canvas

    Source: 12+ must have Atom packages to work in JavaScript | Void Canvas

    IE11 and String.prototype.includes() in Angular directives

    Just come across an interesting behaviour with Angular directives and E11. Apparently E11 does not seem to work with the function String.prototype.includes(), for example:

    [code language=”html”]
    <div ng-if="str.includes(‘test’)" class="someClass"><span>Some text</span></div>
    [/code]

    where str == ‘Sometest‘ and the generic syntax is as below:

    Browser’s compatibility is an issue with IE11 and generally speaking it is poor across IE, so it is highly recommended to use this, instead:

    [code language=”html”]
    <div ng-if="str.indexOf(‘test’) >= 0" class="someClass"><span>Some text</span></div>
    [/code]

    as per the syntax below:

    IndexOf method returns the index of the string as passed in.  If the value is not found, it returns -1.

    Further documentation:

    MDN documentation for includes

    MDN documentation for indexOf

    Build a Watson IBM conversational bot in 15 minutes

    Watson is a question answering system, also know as QA, developed by IBM (named after its IBM’s first CEO Thomas J. Watson) and capable to answer questions posed in natural language. Watson has a variety of applications and domains such as Healthcare , IoT, Education, Financial Services, Marking and Customer Engagement and recently Weather Forecasting. Having come across chatterbots (or chatbots) in the past and always being interested in the long lasting debate around Artificial Intelligence and Thinking Machines (the Turing Test, John Searle’s Chinese Room and many more), I wanted to try out the IBM Watson Conversational Bot and build a simple bot that can have an application in a customer service type of scenario.

    Setting up a Free Account on Bluemix

    It is possible to set up a free Bluemix account to experiment with Watson Conversation. Bluemix is the IBM Cloud Platform as a Service and signing up here you can build your bot by picking Conversation from the IBM Bluemix Catalog. The Lite Pricing Plan (Free) will cover all you need to get started with the bot, for example up to 5 workspaces, up to 25 intents and entities (we will clarify later in this entry what they are). It also includes 10.000 API calls per months (POST message method calls only).

    After selecting the Lite Pricing Plan, a Conversation instance will be created and you will be presented with some info on Conversation and on the right side of the new window the option to launch the instance (via the “Launch tool” button).

    Creating a Workspace

    The very first step into this journey is to create a workspace where you project will reside. Each workspace corresponds to one and only one bot. The below screenshot shows a newly created Workspace named “My First Bot project”

    Screen Shot 2017-10-28 at 20.06.57

    Configuring Intents

    An intent is a task/goal that the user wants to perform or achieve and is expressed by a particular user’s input . For example, changing their password, downgrading their price plan or making a complaint. When planning the intents in your bot application, it is important to consider what the customer/user would like to do in a specific scenario and, in turn, what the bot itself will be able to handle.

    In our example, we will configure 4 classes of intents. 2 for opening and closing statements (greeting the customer’s adviser and parting at the end of conversation) and 2 that would cover requests on the customer’s account.

    • greetings
    • goodbyes
    • account
    • account_changes

    This is the overall UI the user will be presented with showing “Intents”, “Entities” and “Dialog”:

    Screen Shot 2017-10-28 at 20.08.51.png

    Here are (some) intents for the class #greetings:

    Screen Shot 2017-10-28 at 20.11.29.png

    Here some of those for the class #goodbyes:

    Screen Shot 2017-10-28 at 20.15.14.png

    Now that we have covered opening and closing statements in a conversation, we can include some intents for the class #account:

    Screen Shot 2017-10-28 at 21.00.29.png

     

    Still we need to include some training example for out bot to handle the next step in our conversation/dialog. Here some example under the class #account_changes

    Screen Shot 2017-10-28 at 21.02.32.png

     

    There is a last step that in this example will pretty much cover anything else and nothing really specific to what normally a customer would like to ask, but still we need to catch other possible things that can be asked or said. This will be done under the class #anything_else

    Screen Shot 2017-10-28 at 20.38.08.png

    Configuring Entities

    An entity is a term or an object as part of the customer’s input that is aimed at clarifying the intent behind it. When usually intents are verbs (close, pay, change), entities are nouns (an account, a bill, a plan). Ideally, you should group entities that are likely to trigger a similar response throughout your dialog. For example, @customerDetailsChanges, will include all elements in the customer’s address that might need amending or changing as well various operations on the account such as close, pay, change plan etc under the category @accountMaintenance:

    Screen Shot 2017-10-28 at 20.47.25.png

    Screen Shot 2017-10-28 at 20.50.54.png

    Building and Testing the Dialog Flow

    After specifying intents and entities, it is now the time to plan our dialog’s flow. From the Dialog Tab, we are going to set a very basic and initial dialog with the #greetings intent. We create a new node called “Greeting response” and let’s add a new response condition that, if matches the existing intents, it will be prompted to the customer.

    On the right side of your workspace there is a speech bubble with three dots. When you click on it, it will open a chat window from where you can test the current built dialog. As you can see from the below screenshot, “Hi” is correctly recognised as part of the class of intents called #greetings and the response “Hi, how can I help?”.

    Screen Shot 2017-10-28 at 22.59.30.png

     

    Having started off with #greetings, now we need to build the rest of the dialog. We will need to add 3 additional nodes:

    • Account Management.
    • Account Change Requests
    • Goodbye response

    #Account Management’s node targets the intent #account and the entity @accountMaintenance as set earlier in this entry.

    Screen Shot 2017-10-29 at 20.52.47.png

     

    Furthermore, we will need to create a node for the specific request the customer would like to enquiry about (e.g. change of address), as follows:

    Screen Shot 2017-10-29 at 20.48.18.png

    We also need to add another node called “Goodbye response” to wrap up the interaction with the customer:

    Screen Shot 2017-10-29 at 20.37.54.png

    Now, let’s test the dialog Greeting response -> Customer Details Changes -> Goodbye response, as follows:

    Screen Shot 2017-10-29 at 20.46.40.png

    Finally, let’s try out the bot that consists of Greeting response -> Account Management -> Goodbye response, as follows:

    Screen Shot 2017-10-29 at 23.46.15

    Next Steps

    There are a few directions you can go from here . First of all, the above bot is a very basic one, so you can enrich it by planning some additional potential scenarios and including more potential responses and interactions. You can look at using Jump to actions, add variation to your responses or add response conditions (e.g. using context variables). You can also use the Conversation REST API to modify your dialog programmatically, meaning that you will not need to use the Conversation tool UI. Once you are satisfied with your bot, you can also deploy your application by connecting the workspace to an interface customers will use. For example, you can test your bot on Slack in just a few simple steps. Finally, you can use the Watson SDK to develop your own web application and then your using with your service or integrating with 3rd party services.

    (Some) References:

    IBM Watson official website

    IBM Watson official YouTube channel

    Watson API and documentation

    Swagger Documentation for the Watson API

    Watson Conversation 

    Watson IoT GitHub repo

    Watson Cognitive Cooking Community

    Yahoo open-sources Vespa, its most important software release since Hadoop – SiliconANGLE

    Source: Yahoo open-sources Vespa, its most important software release since Hadoop – SiliconANGLE

    What is cool in Java 8 and what is cooler in Java 9!

    JSLT: 5 minutes with core JSLT tags

    JSLT is a tag library provided by Sun, which has support for common tasks such as iteration and conditional execution, database access, tags for manipulating XML documents, internationalization. It is also possible to integrate custom tags with the default JSTL tags. There are in total 6 JSLT tag library descriptors, a few from the core library are presented in this blog entry.

    <c:if> tag

    <code><c:if></code> identifies an if statement, as per the below example. It also includes <code><cl:out></code> displays the result of an expression:

    <c:choose> tag

    The <code><c:choose></code> establishes the context for non mutually exclusive, meaning that there is room for multiple if else clauses via <code><c:when></code> and <code></c:otherwise></code> tags:

    <c:forEach> tag

    The tag <code><c:forEach></code> is for the basic iteration functionality.

    My Most Useful IntelliJ IDEA Keyboard Shortcuts | Roberto Cortez Java Blog

    Source: My Most Useful IntelliJ IDEA Keyboard Shortcuts | Roberto Cortez Java Blog

    %d bloggers like this: