Home

In this topic:

Getting Started with IBM Streams v4.2 Quick Start Edition

Edit me

Download and Install

If you haven’t downloaded and installed the Streams QSE, the preceding section has instructions.

Streams Overview

For a quick overview about Streams and developing in Streams, see the following video:

Getting Started for the Developer

As a developer, you want to:

  • Learn about Streams
  • Write your first Streams application
  • Work with the development tooling in Streams

Below are some resources to get you up and running!

Developing applications in Java, Scala or Python

In addition to Streams Processing Language (SPL, discussed below), Streams applications can be created in Java, Scala, and Python.

Example Streams Application:

package simple;

  import com.ibm.streamsx.topology.TStream;
  import com.ibm.streamsx.topology.Topology;
  import com.ibm.streamsx.topology.context.StreamsContextFactory;

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

          /*
           * Create the container for the topology that will
           * hold the streams of tuples.
           */
          Topology topology = new Topology("HelloWorld");

          /*
           * Declare a source stream (hw) with String tuples containing two tuples,
           * "Hello" and "World!".
           */
          TStream<String> hw = topology.strings("Hello", "World!");

          /*
           * Sink hw by printing each of its tuples to System.out.
           */
          hw.print();

          /*
           * At this point the topology is declared with a single
           * stream that is printed to System.out.
           */

          /*
           * Now execute the topology by submitting to a StreamsContext.
           * If no argument is provided then the topology is executed
           * within this JVM (StreamsContext.Type.EMBEDDED).
           * Otherwise the first and only argument is taken as the
           * String representation of the desired context
           */
          if (args.length == 0)
              StreamsContextFactory.getEmbedded().submit(topology).get();
          else
              StreamsContextFactory.getStreamsContext(args[0]).submit(topology)
                  .get();
      }
  
package simple

    import com.ibm.streamsx.topology.Topology
    import com.ibm.streamsx.topology.streams.BeaconStreams
    import com.ibm.streamsx.topology.context.StreamsContextFactory

    import java.util.concurrent.TimeUnit

    import com.ibm.streamsx.topology.functions.FunctionConversions._

    object HelloWorldScala {
      def main(args: Array[String]) {
        val topology = new Topology("HelloWorldScala")

        var hw = topology.strings("Hello", "World!")    
        hw.print()

       StreamsContextFactory.getStreamsContext("EMBEDDED").submit(topology).get()
      }
    }
    
import sys
from streamsx.topology.topology import Topology
import streamsx.topology.context
import hello_world_functions


def main():
    """
    Sample Hello World topology application. This Python application builds a
    simple topology that prints Hello World to standard output.

    The application implements the typical pattern
    of code that declares a topology followed by
    submission of the topology to a Streams context.

    This demonstrates the mechanics of declaring a topology and executing it.

    Example:
        python3 hello_world.py
    Output:
        Hello
        World!
    """

    # Create the container for the topology that will hold the streams of tuples.
    topo = Topology("hello_world")

    # Declare a source stream (hw) with string tuples containing two tuples,
    # "Hello" and "World!".
    hw = topo.source(hello_world_functions.source_tuples)

    # Sink hw by printing each of its tuples to standard output
    hw.print()

    # At this point the topology is declared with a single
    # stream that is printed to standard output

    # Now execute the topology by submitting to a standalone context.
    streamsx.topology.context.submit("STANDALONE", topo.graph)


if __name__ == '__main__':
    main()

def source_tuples():
    """
    Returns an iterable of strings
    """
    return ["Hello", "World!"]

To get started, follow these development guides:

Developing applications using Streams Processing Language (SPL)

The Streams Processing Language is designed from the ground up for writing streaming applications. To quickly get started:

Streams is shipped with comprehensive development tooling.

Streams Studio

To learn about how to develop using Streams Studio (our drag-and-drop IDE):

Writing Java Operators

If you have existing Java code, you may easily reuse your code by writing a Java operator or native Java functions.

SparkMLLib in Streams

To get started, follow this development guide:

Apache Edgent (aka Open Embedded Streams) Integration

Gather local, real-time analytics from equipment, vehicles, systems, appliances, devices and sensors of all kinds. To get started, check out the Apache Edgent website for more information and guides:

Getting Started for the Data Engineer

As a Data Engineer, you are responsible for:

  • Designing, building, and managing data and analytic systems to ensure they are secure, reliable, and scalable
  • Making all data, including data in motion, available for analysis by other team members such as data scientists and developers
  • Capturing data in motion and integrating it with data at rest
  • Leveraging the newest technologies for stream computing

Below are some resources to help you get started.

Integrating with Streams

Streams is shipped with many toolkits out of the box to enable integration with some of the most popular systems like HDFS, HBase, Kafka, Active MQ and more. To learn about the set of toolkits that are shipped as part of the Streams product, refer to the Product Toolkits Overview

IBMStreams on GitHub provides a platform enabling Streams to rapidly deliver our support to emgerging technologies to you. It is also a place for us to share sample applications and helpful utilities. For a list of open-source projects hosted on GitHub, see: IBM Streams GitHub Projects Overview

Integration with IBM InfoSphere Data Governance Catalog

With this support, developers can easily discover the data and schema that are available for use. By building data lineage with your Streams application, you can quickly see and control how data is consumed. To get started, refer to Streams Governance Quickstart Guide

Cybersecurity Toolkit

The Cybersecurity Toolkit provides operators that are capable of analyzing network traffic and detecting suspicious behaviour. For more information on using the Cybersecurity Toolkit, refer to Cybersecurity Getting Started Guide

Streams and SPSS

SPSS is analytic predictive software enabling you to build predictive model from your data. Your application may perform real-time predictive scoring by running these predictive models using the SPSS operators.

To learn about Streams can integrate with SPSS: Streams and SPSS Lab.

Streams Domain Management and Administration

Streams Console is the web-based administration console for monitoring and managing your Streams domain. Create customized dashboards to monitor your Streams domain, instances and applications.

Streams Console

To familiarize yourself with the Streams Console, see this video:

Getting Started for the Business User

As a business user, you need to:

  • Identify patterns, trends, risks and opportunities in data
  • Build predictive analytic models
  • Use visualization tools to explore and uncover high value data.

Below are some resources to help you get started.

Streams and Microsoft Excel

Streams and Excel

IBM Streams integrates with Microsoft Excel, allowing you to see, analyze and visulize live streaming data in an Excel worksheet. This article helps you get started: Streams for Microsoft Excel

In the following demo, we demonstrate how you may build a marketing dashboard from real-time data using Excel.

Operational Decision Manager (ODM)

IBM Streams integrates with ODM rules, allowing you to create business rules, construct rule flows, and create and deploy rules applications to analyze data and automate decisions in real-time. This article helps you get started: ODM Toolkit Lab

Streams Community

The following Streams resources can help you connect with the Streams community and get support when you need it:

  • Streamsdev - This resource is a developer-to-developer website maintained by the Streams Development Team. It contains many useful articles and getting started material. Check back often for new articles, tips and best practises to this website.
  • Streams Tutorials Hub A collection of available tutorials, labs and courses.
  • Streams Forum - This forum enables you to ask, and get answers to your questions, related to IBM Streams. If you have questions, start here.
  • IBMStreams on GitHub - Streams is shipped with many useful toolkits out of the box. IBMStreams on GitHub contains many open-source toolkits. For a list of available toolkits available on GitHub, see this web page: IBMStreams GitHub Toolkits.
  • IBM Streams Support - This website provides information about IBM Streams downloads, technical support tools, documentation, and other resources.
  • IBM Streams Product Site - This website provides a broad range of information and resources about Streams and related topics.