Qlik Community

Ask a Question

Blogs

Hear directly from Qlik employees in our ten unique blogs.

Announcements
Support Cases coming to Qlik Community Oct. 4! Start chats, open cases, explore resources. Prep for the big move: READ DETAILS
cancel
Showing results for 
Search instead for 
Did you mean: 

Qlik Academic Program Blog

This forum was created for professors and students using Qlik within academia.

Qlik Product Innovation Blog

Learn about what's new across all of the products in our growing Qlik product portfolio.

Support Updates Blog

Important and useful support information about end-of-product support, new service releases, and general support topics.

Qlik Design Blog

All about product and Qlik solutions: scripting, data modeling, visual design, extensions, best practices, etc.

Community News

Updates about Qlik Community Platform as well as news and announcements.

Qlik Education Blog

On this forum you can access and follow the latest updates of our courses and programs with the Qlik Education team.

Qlik Technical Bulletin Blog

Information on all new product releases, connectors, beta programs, and technical product information.

Qlik Architecture Deep Dive Blog

Deep dives into specific back-end technologies which allow for the extension of Qlik to fit the needs of the enterprise.

Qlik Customer Success Blog

All about Qlik's Voice of the Customer program and Customer Success initiatives

Product Insight Blog

Learn about what's new in the Qlik Product Insight & Ideas forum.

Recent Blog Posts

  • Image Not found

    Qlik Design Blog

    Creating 3D bars on a Map with Nebula.js

    Creating 3D bars on a map using Nebula.js, Mapbox GL and Three.js.
  • qlik-community-blogs.jpg

    Qlik Design Blog

    AJAX and URL parameters

    Sometimes you want QlikView to open with a specific set of selections, apply a bookmark or perhaps even deep link to a specific sheet.A typical use case could be to embed an entire app or a single object inside a CRM or ERP system and depending on the context, current customer for example, filter the QlikView app to only show records related to that specific context.So how do I use this black magic?One approach would be to use triggers with the o... Show More

    Sometimes you want QlikView to open with a specific set of selections, apply a bookmark or perhaps even deep link to a specific sheet.

    A typical use case could be to embed an entire app or a single object inside a CRM or ERP system and depending on the context, current customer for example, filter the QlikView app to only show records related to that specific context.

    So how do I use this black magic?


    One approach would be to use triggers with the obvious downside being that the trigger would always fire regardless of how you opened the app.

    Another approach is to supply a set of parameters to the URL for that specific app.

    Let’s take an example, the Sales Compass demo from the demo site. Below us the URL to access the app and the different components explained.

    Actual URL

    demo.qlik.com/QvAJAXZfc/opendoc.htm?document=qvdocs%2FSales%20Compass.qvw&host=demo11

    Explained URL

    <host name>/<virtual directory>/opendoc.htm?document=<url encoded full name for the application>&host=<name of QVS>

    In addition to this URL you can also supply some extra parameters to control which actions will fire when the app is opened. For example the URL below will open the Sales Compass app with the value “Q2” selected in the listbox with id LB5699 (yes we create way to many objects )


    demo.qlik.com/QvAJAXZfc/opendoc.htm?document=qvdocs%2FSales%20Compass.qvw&host=demo11&select=LB5699,Q2

    Of course this is only a simple example, in the table below you will find all the available parameters you can append to your URL.

    Feel free to mix and match these til your hearts content.

    ActionParameterExample
    Select a single value&select=<Listbox ID>,<Value>&select=LB01,Total
    Select multiple values&select=<Listbox ID,(Value|Value2)&select=LB02,(2011|2012)
    Open the app on a specific sheet&sheet=<Sheet ID>&sheet=SH01
    Open the app with a bookmark applied&bookmark=<Bookmark ID>&bookmark=Server\BM01

    Wait a minute, you mentioned single objects?

    Ah, yes! When QlikView 11 was launched we also introduced the capability to display a single object from an app.

    This allowed customers to integrate objects from different applications into a single view in a external system. It is also this screen that powers the small devices client.

    Substitute opendoc.htm with singleobject.htm and specify the object id you want to display,

    demo.qlik.com/QvAJAXZfc/singleobject.htm?document=qvdocs%2FSales%20Compass.qvw&host=demo11&object=CH378

    And voila! You now have a fully interactive single QlikView object!

    Show Less
  • Image Not found

    Qlik Design Blog

    Making a Multilingual Qlik Sense App

    A colleague of mine had translated two demos from the Demo Site to Japanese and wanted to know if we could post them on the Demo Site alongside the English versions. We decided that it would be best to combine the English and Japanese versions into one multilingual Qlik Sense app making it easier for us to add additional languages to the app as needed. It was an easy process and required only a few steps:Create a translation sheet with all the la... Show More

    A colleague of mine had translated two demos from the Demo Site to Japanese and wanted to know if we could post them on the Demo Site alongside the English versions. We decided that it would be best to combine the English and Japanese versions into one multilingual Qlik Sense app making it easier for us to add additional languages to the app as needed. It was an easy process and required only a few steps:

    1. Create a translation sheet with all the languages that will be available in the app
    2. Update the script to add a table of the translations and a list of the languages available in the app
    3. Add a Language filter pane to every sheet in the app that allows only one selected value
    4. Update sheet names, chart titles, subtitles and labels with an expression that will display the text in the selected language

    Create Translation Sheet

    To begin the process of making a demo multilingual, I created an Excel file with all the languages that are to be included in the app. Below is a snippet of the worksheet. The first column, Index, has a unique value which will be used in the charts and expressions to indicate what data should be displayed. The second and third columns are the languages to be used in the app. An additional column can be added for additional languages that need to be added to the app. In this scenario, I entered all the English text (sheet names, chart titles and subtitles, labels and text) and then using the Japanese version of the app, I entered the respective Japanese text. If I did not have the Japanese version of the app, I would have shared the Excel file with someone who could enter the Japanese translations for me. Preparing the Excel file in this format makes it easy to add additional languages to the app without having to update the QVF.

    Snippet of Excel translation sheetSnippet of Excel translation sheet

    Update the Script

    Once the translation sheet was created, it needed to be loaded into the data model. The script below is what I added to the demo.

    script.png

    On line 1, the HidePrefix system variable is used to hide all fields that begin with “#.” Starting on line 3, the Excel file is loaded. Once it is loaded, the vLanguage variable is set to the expression “=Minstring(#LANGUAGE).” This is an important step and we will take a closer look at this when we update the front-end. On line 13, the languages from the Excel file are loaded - users can select the language they would like to view from this list. These languages are then stored in the #LANGUAGE field which will be hidden from the user (since it starts with “#”).

    Add Language Filter

    One each sheet in the app, I added a Language filter pane using the dimension #LANGUAGE that was created in the script. Once the script is reloaded with the HidePrefix variable, the #LANGUAGE field will not be visible, but you can still use it as the dimension in the Language filter pane. I needed to see the field temporarily so I commented out the HidePrefix line in the script and reloaded so I could change a setting on the field. I only want the user to be able to select one Language at a time, so I needed to check the “Always one selected value” checkbox in the Field settings of the #LANGUAGE field. (Right click on the #LANGUAGE field and select Field settings to see the window below).

    Field settings dialog windowField settings dialog window

    Once my settings are saved, I uncommented the HidePrefix line and reloaded the app to hide the #LANGUAGE field again. The filter pane will look like this (image below) and only one language can be selected at any given time. When a language is selected, the vLanguage variable (that was created in the script) will store the language. This variable is used later when updating the text in the UI.

    Language filter paneLanguage filter pane

    Update Front-End

    Now the last step is to update everything in the app that should be translated. In this scenario, I updated sheet names, chart titles and subtitles, chart labels, KPI text and text on the sheets. Here is an example of how I updated the title of the Language filter pane. In the title field, I entered:

    index.png

    In the snippet below from the Excel translation sheet, the Index is 64 for the text “Language” which is why I used it in the expression above for the title of the Language filter pane. This expression will return either the English or Japanese translation for Language depending on the value of the variable vLanguage.

    Snippet from Excel translation sheetSnippet from Excel translation sheet

    Another piece of information I would like to share is how I handled Text & image objects that needed to be translated. In the screenshot below, there is heading text and body text that have 2 different formats (font size and font color).

    intro.png

    To handle this, I created two variables, one for the heading and one for the body and in the variables, I stored the translation expression.

    edit intro.png

    variables.png

    This way, I was able to not only translate the text but format the text in a single Text & image chart two different ways.

    As you can see, it is easy to make a Qlik Sense app multilingual and it is easy to update the app with additional languages as needed. Sales, Customer Experience & Churn and Supply Chain – Inventory & Product Availability are the two demos that were made multilingual. Check them out and switch between the languages to see the final results. If you are interested in doing this in QlikView, check out Chuck Bannon’s blog on this topic as well as making the data multilingual in a QlikView app.

    Thanks,

    Jennell

    Show Less
  • qlik-community-blogs.jpg

    Qlik Design Blog

    Bill of Materials

    Most hierarchies are dimensional hierarchies. This implies several things: First, you have a many-to-one relationship between the levels: a day belongs to one (and only one) month, a month to one (and only one) quarter, etc. Strictly speaking, it is not a hierarchy unless this condition is fulfilled.   Secondly, the hierarchy contains no measures. Instead, numbers are stored in a transactional table that is linked to the dimensional hierarchy.   ... Show More

    Most hierarchies are dimensional hierarchies. This implies several things: First, you have a many-to-one relationship between the levels: a day belongs to one (and only one) month, a month to one (and only one) quarter, etc. Strictly speaking, it is not a hierarchy unless this condition is fulfilled.

     

    Secondly, the hierarchy contains no measures. Instead, numbers are stored in a transactional table that is linked to the dimensional hierarchy.

     

    But there is another hierarchy-like structure, the Bill of Materials, the “BoM”. This is a list of items, assemblies and sub-assemblies representing the design of a product or device. Many products are planned and documented with BoMs.

     

    A multi-level BoM depicts parent-child relationships and shows the hierarchical structure of the assemblies and their related subcomponents. A multi-level BoM is essentially a nested list whose items are listed to illustrate multiple assemblies within a product.

     

    BoM input.png

     

    But a BoM is very different from a dimensional hierarchy. It does not have to have a strict many-to-one relationship between the levels. For instance, a specific bearing type can be used in several places. For the BoM, this means that the bearing can have several parents in the hierarchy.

     

    Further, each line in the BoM has numbers in it, typically Quantity and Cost. These are measures that should be summed. In a sense, a BoM is more similar to a transaction table than a dimensional table.

     

    A BoM can easily be loaded and analyzed with Qlik Sense or QlikView, but there are some challenges: First, the list often lacks a parent reference. Instead, the parent-child relationship is implied by the order of the rows and the Level field, and visualized by indentations.

     

    Secondly, aggregating the measures is not straightforward. When summing the costs, the multiplicities of all the nodes above it must be taken into account. In the example in the above table, the wheel assembly uses 2 bearings, and the trailer uses 4 wheel assemblies. Then the trailer obviously needs 8 bearings. In other words: The row for the wheel assembly – and all rows belonging to it – must be looped 4 times when summing the cost.

     

    Luckily, both these challenges can be handled in the Qlik script. One possible solution is the following:

     

       Hierarchy ( [Part No], Parent, Description )

       Load *,

           Subfield( Path, '/', Level ) as Parent;

       Load *,

           Left( Peek( Path ), Index( Peek( Path ) & '/', '/', Level ) -1 ) & '/' & [Part No] as Path

           While IterNo() <= Units;

       Load *,

           If( Frac( Quantity)=0, Quantity, 1 ) as Units,

           If( Frac( Quantity)=0, 1, Quantity ) as Amount

           From BoM ;

     

    The reference to the parent is created in two steps: First a Path is built using the Level and the Path of the above row. Having the path, it is straightforward to extract the parent id using Subfield().

     

    Further, each row is loaded several times using a while loop. Hence, row 16 (the ball bearings) is loaded twice since its Quantity is 2. But it should be loaded 8 times since the Quantity of its parent (row 6, Wheel assembly) is 4. This multiplication is achieved using the Hierarchy prefix.

     

    Finally, the above multiplication algorithm only works for integer quantities. For this reason the bottom Load splits the Quantity into two fields: a field Units that is used in the While loop, and an Amount that is used in the aggregation:

     

       Sum( Amount * UnitCost )

     

    However, this means that nodes that have non-integer quantities cannot have any children. If they do, the above algorithm cannot be used, and the cost roll-up must be made a different way. Luckily, this is rarely or never the case in real life.

     

    Good luck with your Bill of Materials!

     

    HIC

     

    Further reading related to this topic:

    Unbalanced, n-level hierarchies

    Show Less
  • Image Not found

    Qlik Academic Program Blog

    Students from XJTLU-China present Qlik Sense applications at the Summer Bootcamp...

    A Summer Bootcamp was organized by the Data Mining Lab of International Business School Suzhou,  XJTLU, China during  August 16- 20, 2021. Students were asked to build applications using Qlik Sense using different data sets. Their applications were assessed by a panel of judges from the industry.The IBSS@Data Mining Lab was established in November 2015 at International Business School Suzhou (IBSS) in order to support research-led initiatives in ... Show More

    A Summer Bootcamp was organized by the Data Mining Lab of International Business School Suzhou,  XJTLU, China during  August 16- 20, 2021. Students were asked to build applications using Qlik Sense using different data sets. Their applications were assessed by a panel of judges from the industry.

    The IBSS@Data Mining Lab was established in November 2015 at International Business School Suzhou (IBSS) in order to support research-led initiatives in data technology driven management and accounting practices related for Research, Learning and Teaching.

    IBSS@DataMiningLab aims to promote initiatives in Learning & Teaching in the field of Data Analytics and respond to employers needs for new skills in data analytics at IBSS and across XJTLU through cross-departmental initiatives

    IBSS@Data Mining Lab offers free access to professional data analytics software and related learning resources. The Lab is led jointly by International Business School Suzhou (IBSS) and CSSE (Computer Science and Engineering Department) departments of XJTLU.

    During the bootcamp, students presented applications built on Qlik Sense and a panel of judges from the industry assessed these applications. The applications were based on different data sets including sales, logistics, manufacturing etc. and presented interesting insights using features of Qlik Sense.

    Presenting a dashboard using Qlik SensePresenting a dashboard using Qlik Sense

     

    Students were able to demonstrate capabilities of Qlik Sense and build dashboards including graphs, story telling in their presentation.

    The Qlik Academic Program provides free resources in data analytics to support the learning experience of students, to know more visit: qlik.com/academicprogram

    Show Less
  • Image Not found

    Qlik Design Blog

    Reload Logs Reader v 1.0

    In an enterprise environment IT does not give access to the folders where the logs are stored, so developers have to ask to get the logs from IT which can be terribly slow and frustrating.
  • qlik-community-blogs.jpg

    Qlik Product Innovation Blog

    Self-Service Reporting Now Available in Qlik Sense SaaS (Updated)

    We are pleased to announce our first scheduled reporting capability in Qlik Sense SaaS, now also inclusive of a distributed reporting capability 
  • qlik-community-blogs.jpg

    Qlik Product Innovation Blog

    Exciting updates to Qlik Compose and Enterprise Manager are now available

    Our data integration enhancements include simplified data lake creation, improved data warehouse automation, and platform integrations. Changed data propagated to data lake landing zones can now be optionally viewed when current and transactionally consistent leading to accurate, real-time insights. We now add Databricks Delta Lakes on Google’s platform to our ever-expanding list of supported data lakes. With support for a significant number of e... Show More

    Our data integration enhancements include simplified data lake creation, improved data warehouse automation, and platform integrations. Changed data propagated to data lake landing zones can now be optionally viewed when current and transactionally consistent leading to accurate, real-time insights. We now add Databricks Delta Lakes on Google’s platform to our ever-expanding list of supported data lakes. With support for a significant number of entities, automated datamarts can now support more comprehensive analyses. A single user interface to track Compose workflows across lakes and warehouses eases management, while tight integration of ingestion processes from one or many Replicate data pipelines to transformation and provisioning processes automate and speed data delivery to consumers. Lastly, ingestion and transformation of semi-structured data within Snowflake bring in new data sources.

    Show Less
  • Image Not found

    Qlik Academic Program Blog

    Data Literacy within the workforce

    Qlik offers students Data Literacy training and certificates, for FREE!
  • Image Not found

    Support Updates Blog

    Invalid Visualization error with Org chart in Qlik Sense SaaS environments

    Hello Qlik Users!UPDATE on 10/16/2020 - This issue is now resolved.An issue with the Org chart has been identified in the Qlik Sense SaaS environments (Qlik Sense Business and Qlik Sense SaaS). Users may receive the following error with the Org chart:Invalid visualizationThe visualization was not found. This extension is not available in the cloud: sn-org-chart ()This issue is currently being investigated by R&D. If you are seeing this issue, ple... Show More

    Hello Qlik Users!

    UPDATE on 10/16/2020 - This issue is now resolved.

    An issue with the Org chart has been identified in the Qlik Sense SaaS environments (Qlik Sense Business and Qlik Sense SaaS). Users may receive the following error with the Org chart:

    Jamie_Gregory_0-1602777498720.png

    Invalid visualization

    The visualization was not found. This extension is not available in the cloud: sn-org-chart ()

    This issue is currently being investigated by R&D. If you are seeing this issue, please create a case with Qlik Support and reference defect QLIK-103217. For more information about the issue, please see "Invalid visualization" with Org Chart on Qlik Sense Business and Qlik Sense Enterprise SaaS.

    I will keep everyone updated on the progress of this issue within this blog so please stay tune.

    Kind regards,

    Qlik Digital Support

    Show Less
  • Image Not found

    Qlik Education Blog

    NEW Qlik Sense Business Analyst Certification Exam - Get certified on February 2...

    Pre-Registration Now Available!Qlik Sense Business Analyst Certification Exam is available - testing begins September 13th, 2021. Pre-register now for the best choice of appointment times. 
  • Image Not found

    Qlik Design Blog

    k-Means clustering using Qlik's Nebula.js

    In the past few years, Qlik Sense has introduced a solid range of advanced analytics capabilities that compliments the Data Analytics platform. This includes using techniques such as Machine Learning, Natural Language Processing, etc. to help analysts/scientists explore data in a better way, get insights into any hidden patterns & take necessary actions. Bringing these methods together with the Data Analytics platform is often termed ‘Augmented I... Show More

    In the past few years, Qlik Sense has introduced a solid range of advanced analytics capabilities that compliments the Data Analytics platform. This includes using techniques such as Machine Learning, Natural Language Processing, etc. to help analysts/scientists explore data in a better way, get insights into any hidden patterns & take necessary actions. Bringing these methods together with the Data Analytics platform is often termed ‘Augmented Intelligence’. For a more detailed description of the what’s & why’s, please refer to this link.

    Dipankar_Mazumdar_0-1629993823362.png

    Problem:

    Consider the following scenario. An analyst needs to explore geographical data for a variety of neighborhoods in Toronto to help the city’s crime department set up some hotspots to monitor the neighborhoods and analyze the criminal activities in an effective way. Segregating the neighborhoods into five different clusters based on some kind of similarities between them would be the first step.

    Qlik Sense client approach:

    A solution to this from the Qlik Sense client perspective would be to use the KMeans2D chart function that applies k-Means clustering internally and calculates the cluster_id for each of the neighborhoods. The results can then be visualized in the form of a Scatter plot with latitude on the X-axis, longitude on the Y-axis, and bubbles representing each neighborhood’s ID. Here’s a snippet that shows the data configuration.

    Dipankar_Mazumdar_1-1629993953255.png

     

    To visually explain the five clusters, the chart can be ‘colored by dimension’ based on the cluster_id’s. Please note that we use color by dimension (and use a dimension expression) and not color by expression. Here’s where we define our dimension expression.

    Dipankar_Mazumdar_2-1629993953280.png

     

    Expression:

    =pick(aggr(KMeans2D(vDistClusters,only(Lat),only(Long)),FID)+1, 'Cluster 1', 'Cluster 2', 'Cluster 3', 'Cluster 4','Cluster 5')

     

    Embedded Analytics approach:

    Now, consider that you are a full-stack Qlik developer and you leverage the open-sourced Nebula.js library to build your analytics portal. What would be an easy way for you to apply k-Means clustering to this dataset without relying on any 3rd-party libraries?

     

    Solution:

    Technically there are two ways to achieve this using Nebula.js.

    1. Develop the visualization in Qlik Sense client & embed it to your page.

    2. Develop a visualization on the fly & use the kMeans2D chart function.

    The first point is fairly simple & straightforward. You can create your Scatter plot in the Qlik Sense client and just call the <object_id> using Nebula’s render( ) function like this.

    n.render({
      element,
      id: '<ObjectID>',
    });

     

    In this blog post, we will keep our focus on Point 2. i.e. we will develop a visualization on the fly and then apply the clustering algorithm using the chart function to achieve our goal. 

     

    Implementation:

    Before we start developing the visualization, let’s recap one of the amazing things about Nebula.js. It is a collection of JavaScript libraries, visualizations, and CLIs that helps developers build and integrate visualizations on top of Qlik's Associative Engine. Essentially it serves as a wrapper on top of the Engine allowing us to use expressions as we can inside the Qlik Sense client. 

    Since Nebula sits on top of the Engine, we also have direct access to the data (dimensions & measures) from the Qlik Sense app that is connected to our Nebula app. This makes building an existing or custom visualization using Nebula easier & quicker from a data structure perspective. It also goes without saying that Qlik Sense ‘associations’ works seamlessly when using Nebula.

    Now, let’s quickly build an on-the-fly scatter plot and use the kMeans2D chart function to color each point/bubble on our plot. 

    Step 1: Define the qAttributeDimensions for the ‘dimension expression’.

    qAttributeDimensions: [
              {
                qDef:
                  "=pick(aggr(KMeans2D(vDistClusters, only(Lat), only(Long)), FID)+1, 'Cluster 1', 'Cluster 2', 'Cluster 3', 'Cluster 4', 'Cluster 5')",
                qAttribute: true,
                id: "colorByAlternative",
                label: "Cluster id"
              }
            ]
          }
        ],

    Since we would like to use color by dimension as a coloring technique in our scatter plot, we have to explicitly specify it using id:"colorByAlternative" in the qDef as shown in the above code. An alternative to this would be id: "colorByExpression" if we wanted to color by expression.

    Also, we use a dimension expression (not just a dimension field) in the qDef property of qAttributeDimensions. Therefore, the dimension expression has to be defined inside the qDef property (as shown in the code).

    Step 2: Define the properties.

    Next, we define the required properties in the root of the object. An important property here is the color. We tell Nebula to not color our chart automatically first (code below) so we can override using our expression’s color. Also, we set have to set the right color mode inside the color. In our case, it is “byDimension”.

    The other crucial property within color is byDimDef. It is used to configure the settings for coloring the chart by dimension. byDimDef consists of three properties -

    • type - either ‘expression’ | ‘libraryItem’

    • key - if it is a ‘libraryItem’, then the libraryId | dimension expression if using an ‘expression’

    • label - Label displayed for coloring (in the legend). Can be string | expression

    The code for defining the properties is below.

      properties: {
          title: "k-Means clustering",
          color: {
            auto: false,
            mode: "byDimension",
            byDimDef: {
              type: "expression",
              key:
                "=pick(aggr(KMeans2D(vDistClusters, only(Lat), only(Long)), FID)+1, 'Cluster 1', 'Cluster 2', 'Cluster 3', 'Cluster 4', 'Cluster 5')",
              label: "Cluster id"
            }
          }
        }

     

    That is pretty much it! To elucidate the clustering method, we also embed a scatter plot to our Nebula app with non-clustered data.

    Let us take a look at the two plots -

    Dipankar_Mazumdar_3-1629994094021.png

     

    Using the KMeans2D function the neighborhoods have now been segregated into five different clusters based on their similarity. The color by cluster helps us in interpreting the five groups distinctly.


    Before we end this post, let’s take a look at the clustering function once and understand the parameters.

    KMeans2D(num_clusters, coordinate_1, coordinate_2 [, norm])
    • num_clusters - implies the no. of cluster we would like to have. Typically this value is calculated using the elbow curve or silhouette analysis methods. Read more  here.

    • coordinate_1, coordinate_2 - indicates the columns used by the clustering algorithm. These are both aggregations.

    • norm - This is an optional normalization method applied to datasets before k-Means clustering. Possible values are - (0/‘none’ - no normalization, 1/ ‘zscore’ -zscore normalization, 2/‘minmax’ - min-max normalization).

    In our current Nebula application, we play around with the num_clusters parameter to understand the differences such as neighborhood overlaps, etc. We embed three action-buttons in our dashboard and the final result can be seen below.

    Dipankar_Mazumdar_4-1629994103289.gif

     

    The complete project can be found on either my Github repo or this Glitch.

    Let me know if you have any interesting ideas to apply clustering or any advanced analytical methods using Nebula.js.

    ~Dipankar

    Show Less
  • qlik-community-blogs.jpg

    Qlik Design Blog

    The Master Calendar

    One of the most common problems to solve in data modeling is that of time. How to assign month name and other time attributes to a date. The solution is called a master calendar.
  • Image Not found

    Qlik Product Innovation Blog

    Client-Managed Qlik Product Release August 2021

    Today we not only released several new SaaS enhancements but also released our client-managed August 2021 products for Qlik Sense and Qlik Compose further extending our end-to-end offering.
  • Image Not found

    Qlik Design Blog

    Analyzing the 2021 Global 500

    In a new chapter of our collaboration with the Fortune Magazine I'm proud to introduce today the 2021 Global 500. In this year's Global 500 app we are aiming to throw some light over the impact of COVID-19 on the list.We analyzed how two of the list’s main indicators evolved over the years. In 2021 Revenue saw a 5% decline while Profits plummeted some 20% to $1.65 trillion. It was the biggest decline since a 48% plunge in 2009.  But not all the r... Show More

    In a new chapter of our collaboration with the Fortune Magazine I'm proud to introduce today the 2021 Global 500. In this year's Global 500 app we are aiming to throw some light over the impact of COVID-19 on the list.

    We analyzed how two of the list’s main indicators evolved over the years. In 2021 Revenue saw a 5% decline while Profits plummeted some 20% to $1.65 trillion. It was the biggest decline since a 48% plunge in 2009.

     

    ArturoMuoz_1-1629196898774.jpeg

     

    But not all the regions performed in the same way, to visualize the impact of the economic crisis that followed the COVID-19 pandemic we plotted the contribution of different regions to the Global 500 list using two measures, number of companies and revenue.

    ArturoMuoz_2-1629196898975.jpeg

    The chart above shows how each region have performed since the first Global 500 list was published back in 1990. When looking at each evolution line, the meteoric rise of China over the years it's very impressive while Europe’s dominant position on the list on decline.

    In 2021 the European countries were heavily impacted by the economic shutdown. Europe's representation in the list dropped in number of companies and their reported revenues decreased as well. Other regions like China continued to thrive despite of the current world situation. The US position remained almost unchanged when compared with the previous year 2020.

    To focus even more in the 2020-2021 change readers can check the next section, where a world map holds indicators that helps us to visualize the change. The image below shows 2020-2021 change measured in number of companies in the Global 500 list. Again, Europe dominate the losses while both US and specially China increase the number of companies with presence in the list.

    ArturoMuoz_3-1629196899103.png

     

    We putted an end to the app analyzing how each sector behaved last year. The chart below shows the size of the entire economy in 2020 and in 2021 (Profits). The entire Global 500 list profits dropped by 20% year over year, but not every sector was impacted equally. Technology, Telecommunications and Retailing increased their profits while the Energy sector took a massive hit on profits losing 1.7 trillion USD disappearing from the top sectors measured by profits.   

    ArturoMuoz_4-1629196899302.jpeg

     

    We really hope you enjoy the experience, don’t forget to check the live app here: https://qlik.fortune.com/global500

    Enjoy it! 😊

     

    Show Less
  • Image Not found

    Qlik Design Blog

    Picasso.js - What separates it from other visualization libraries and how to bui...

    Picasso.js has been there for a while since its first release in 2018. It is an open-source charting library that is designed for building custom, interactive, component-based powerful visualizations.Now, what separates Picasso from the other available charting libraries?Apart from the fact that Picasso.js is open-sourced, here is my take on certain other factors -Component-based visuals: A visualization usually comprises various building blocks ... Show More

    Picasso.js has been there for a while since its first release in 2018. It is an open-source charting library that is designed for building custom, interactive, component-based powerful visualizations.

    Now, what separates Picasso from the other available charting libraries?

    Apart from the fact that Picasso.js is open-sourced, here is my take on certain other factors -

    1. Component-based visuals: A visualization usually comprises various building blocks or components that form the overall chart. For example, a Scatter plot consists of two axes with one variable on each of the axes. The data is displayed as a point that shows the position on the two axes(horizontal & vertical). A third variable can also be displayed on the points if they are coded using color, shape, or size. What if instead of an individual point you wanted to draw a pie chart that presents some more information? Something like this - 

      Dipankar_Mazumdar_0-1629400220573.png

      As we can see on the right-side image, a correlation between Sales and Profit is projected. However, instead of each point, we have individual pie charts that show the category-wise sales made in each city. This was developed using D3.js- a library widely used to do raw visualizations using SVGs.

      Picasso.js provides a similar level of flexibility when it comes to building customized charts. Due to its component-based nature, you can practically build anything by combining various blocks of components.

    2. Interactive visuals: Combining brushing and linking is key when it comes to interactivity between various visual components used in a dashboard or web application. Typically what it means is if there are any changes to the representation in one visualization, it will impact the others as well if they deal with the same data (analogous to Associations in Qlik Sense world). This is crucial in modern-day visual analytics solutions and helps overcome the shortcomings of singular representations. 

      Picasso.js provides these capabilities out of the box. Here is an example of how you could brush & link two charts built using Picasso:

      const scatter = picasso.chart(/* */);
      const bars = picasso.chart(/* */); scatter.brush('select').link(bars.brush('highlight'));
       
    3. Extensibility: What if you wanted to create visualizations with a set of custom themes that aligns with your organization? What if you needed to bind events using a third-party plugin like Hammer.js? Most importantly for Qlik Sense users, how do you bring the power of associations to these custom charts? Picasso.js allows users to harness these capabilities easily.
    4. D3-style programming: Picasso.js leverages D3.js for a lot of its features and this allows the D3 community to reuse and easily blend D3-based charts into the Picasso world. Having come from a D3.js background, I realized how comfortable it was for me to scale up when developing charts using Picasso since the style of programming(specifically building components) was very common.

    If you would like to read more about the various concepts & components of Picasso, please follow the official documentation.


    Now that we know a bit more about Picasso.js, let us try to build a custom chart and try to integrate it with Qlik Sense’s ecosystem, i.e. use selections on a Qlik Sense chart and apply it to the Picasso chart as well.

    Prerequisite: picasso-plugin-q

    In order to interact with and use the data from Qlik’s engine in a Picasso-based chart, you will need to use the q plugin. This plugin registers a q dataset type making data extraction easier from a hypercube.

    Step 1: Install, import the required libraries for Picasso and q-plugin and register -

    npm install picasso.js
    import picassojs from 'picasso.js';
    import picassoQ from 'picasso-plugin-q';
    
    picasso.use(picassoQ); // register

     

    Step 2: Create hypercube and access data from QIX -

     const properties = {
        qInfo: {
          qType: "my-stacked-hypercube"
        },
        qHyperCubeDef: {
          qDimensions: [
            {
              qDef: { qFieldDefs: ["Sport"] },
            }
          ],
          qMeasures: [
            { qDef: { qDef: "Avg(Height)" } 
            },
            { qDef: { qDef: "Avg(Weight)" }
            }
          ],
          qInitialDataFetch: [{ qTop: 0, qLeft: 0, qWidth: 100, qHeight: 100 }]
        }
      };

     

    Our idea is to build a scatter plot to understand the height-weight correlation of athletes from an Olympic dataset. We will use the dimension ‘Sport’ to color the points. Therefore, we retrieve the dimension and 2 measures(Height, Weight) from the hypercube.

    Step 3: Getting the layout and updating -

    Once we create the hypercube, we can use the getLayout( ) method to extract the properties and use it to build and update our chart. For this purpose, we will create two functions and pass the layout accordingly like below.

    const variableListModel = await app
        .createSessionObject(properties)
        .then(model => model);
    
      variableListModel.getLayout().then(layout => {
        createChart(layout);
      });
    
      variableListModel.on('changed',async()=>{
        variableListModel.getLayout().then(newlayout => {
        updateChart(newlayout);
      });
      });

    First, we pass the layout to the createChart( ) method, which is where we build our Scatter plot. If there are any changes to the data, we call the updateChart( ) method and pass the newLayout so our chart can reflect the updated changes.

    Step 4: Build the visualization using Picasso.js -

    We need to let Picasso know that the data type we will be using is from QIX, i.e. q and then pass the layout like below:

    function createChart(layout){ 
    chart = picasso.chart({
     element: document.querySelector('.object_new'),
      data: [{
        type: 'q',
        key: 'qHyperCube',
        data: layout.qHyperCube,
      }],
    }

     

    Similar to D3, we will now define the two scales and bind the data (dimension & measure) extracted from Qlik Sense like this:

     scales: {
          s: {
            data: { field: 'qMeasureInfo/0' },
            expand: 0.2,
            invert: true,
          },
          m: {
            data: { field: 'qMeasureInfo/1' },
            expand: 0.2,
          },
          col: {
            data: { extract: { field: 'qDimensionInfo/0' } },
            type: 'color',
          },
        },

    Here, the scale s represents the y-axis and m represents x-axis. In our case, we will have the height on the y-axis and weight on the x-axis. The dimension, ‘sports’ will be used to color as mentioned before.

    Now, since we are developing a scatter plot, we will define a point component inside the component section, to render the points.

      key: 'point',
          type: 'point',
          data: {
            extract: {
              field: 'qDimensionInfo/0',
              props: {
                y: { field: 'qMeasureInfo/0' },
                x: { field: 'qMeasureInfo/1' },
              },
            },
          },

     

    We also pass the settings of the chart inside the component along with the point like this:

    settings: {
            x: { scale: 'm' },
            y: { scale: 's' },
            shape: 'rect',
            size: 0.2,
            strokeWidth: 2,
            stroke: '#fff',
            opacity: 0.8,
            fill: { scale: 'col' },
          },

    Please note that I have used the shape ‘rect’ instead of circle here in this visualization as I would like to represent each point as a rectangle. This is just an example of simple customization you can achieve using Picasso.

    Finally, we define the updateChart( ) method to take care of the updated layout from Qlik. To do so, we use the update( ) function provided by Picasso.

     function updateChart(newlayout){
           chart.update({
           data: [{
        type: 'q',
        key: 'qHyperCube',
        data: newlayout.qHyperCube,
      }],
        });
            }

    The result is seen below:

    Dipankar_Mazumdar_1-1629400220563.png

     

     

    Step 5: Interaction with Qlik objects -

    Our last step is to see if the interactions work as we would expect with a native Qlik Sense object. To clearly depict this scenario, I use Nebula.js (a library to embed Qlik objects) to call & render a predefined bar chart from my Qlik Sense environment. If you would like to read more on how to do that please refer to this. Here’s a sample code.

        n.render({
        element: document.querySelector(".object"),
        id: "GMjDu"
      })

    And the output is seen below. It is a bar chart that shows country wise total medals won in Olympics.

    Dipankar_Mazumdar_2-1629400220534.png

     


    So, now in our application, we have a predefined Qlik Sense bar chart and a customized scatter plot made using Picasso.js. Let’s see their interactivity in action.

    ezgif.com-video-to-gif-5.gif

    The complete code for this project can be found on my GitHub.

    This brings us to an end of this tutorial. If you would like to play around, here are a few collection of Glitches for Picasso. You can also refer to these set of awesome examples in Observable.

    Show Less
  • Image Not found

    Support Updates Blog

    Our Support Bot is Learning!

     It’s been three weeks since we launched our bot, and we’ve learned a lot! And by “we”, I mean us humans AND the bot! Recent enhancements include:  Improved instructions for creating a case  Revamped our license conversations flows to improve the success rate  Made matching against login and access issues less “greedy” to improve accuracy  Improved logic for login and access issues  Improved training phrases for “request an agent” and “download ... Show More

     It’s been three weeks since we launched our bot, and we’ve learned a lot! And by “we”, I mean us humans AND the bot! Recent enhancements include: 

    • Improved instructions for creating a case 
    • Revamped our license conversations flows to improve the success rate 
    • Made matching against login and access issues less “greedy” to improve accuracy 
    • Improved logic for login and access issues 
    • Improved training phrases for “request an agent” and “download a product” 
    • Added a new download conversation flow 

     

    And we have more improvements in progress based on the conversations the bot has had so far. When we set out, we trained the bot against an analysis of 2 years of case and chat transcript data, but we’ve been pleasantly surprised by the variety of questions we are getting. Rest assured that we are working diligently to improve the bot’s ability to recognize customer questions and provide the correct answer. 

    Our system uses a sophisticated machine learning algorithm to analyze conversations based on match rates, completions, abandons, and escalations, and then recommends changes to our conversation flows and intents. These recommendations are reviewed daily by our team at Qlik. We then make updates to content and flow designs, or create all new flows to address new types of questions. 

    In our first week, we saw a steady increase in the % of questions the bot recognized as we tweaked the original design based on the initial training. In the last two weeks, though, we’ve seen the start of a pattern where the match rate is high on Monday, then declines through the week as volume increases. Then we roll out changes on Friday and the match rate jumps back up! We expect this to continue for a few more weeks as we collect the initial breadth of questions customers expect the bot to answer. 

    Thank you to everyone who has chatted with the bot, and stay tuned for more updates! 

    Qlik Digital Support

    Show Less
  • qlik-community-blogs.jpg

    Qlik Product Innovation Blog

    Everyone can get prompted for timely action. Data Alerting is now also included...

    Your welcome.    By now you might already have started to use alerting across your enterprise to aid in taking action in the business moment.   We have extended intelligent data alerting to all Qlik Sense SaaS users!   The full set of alerting features are now available for all SaaS user types including Professional, Analyzer and Analyzer Capacity – making it easier to drive adoption and expand insights!
  • Image Not found

    Support Updates Blog

    The App Analyzer for Qlik SaaS customers is available NOW!

    Hello Qlik Users! How can I track app RAM usage over time?   How do I optimize my applications so that they can stay under the limit?   These are a couple of the questions we frequently hear. There hasn’t been a clear way to get a holistic picture of what is happening within your tenant… Until now. I am happy to share with you the new App Analyzer for Qlik SaaS! The App Analyzer will help answer those questions and more! The app provides insight... Show More

    Hello Qlik Users!

    How can I track app RAM usage over time?
     
    How do I optimize my applications so that they can stay under the limit?
     

    These are a couple of the questions we frequently hear. There hasn’t been a clear way to get a holistic picture of what is happening within your tenant…

    Until now.

    I am happy to share with you the new App Analyzer for Qlik SaaS!

    AppAnalyzerwithborder.png

    The App Analyzer will help answer those questions and more! The app provides insights on:

    • App, Table and Field memory footprints
    • Synthetic keys and island tables to help improve app development
    • Threshold analysis for fields, tables, rows and more
    • Reload times and peak RAM utilization by app
    • And much more!

    Jamie_Gregory_1-1597163015603.png

    The App Analyzer uses a single REST connection to iterate over application metadata endpoints within a tenant. The data retrieve can then be measured against tenant quotas and user-defined thresholds to empower Admins to act on the insights that the app reveals. To see the app in action, check out this demo:

    A few things to note:

    • This app is provided as-is and is not supported by Qlik Support.
    • An undocumented API was used in the document script that is experimental.
    • It is recommended to always use the latest app.
    • Information is not collected by Qlik when using this app.

     

    The app as well as the configuration guide can be found at the bottom of this post. This app was created internally and will be supported by the developers of the app. They will be following this thread so be sure to post any questions or issues here so they can be addressed.

    Be sure to subscribe to the Qlik Support Updates Blog by clicking the green Subscribe button to stay up-to-date with the latest Qlik Support announcements. Please give this post a like if you found it helpful!

    Kind regards,

    Qlik Digital Support Team

     

    Update 10/7/2020 - New version of App Analyzer (v3.0.1) uploaded

    Update 1/21/2021 - The App Analyzer has been updated and uploaded

    Update 8/24/2021 - App Analyzer's latest update is reflected in the attachment below

    Show Less
  • Image Not found

    Qlik Design Blog

    Is there really one type of Ad-hoc Reporting with Qlik Sense?

    A question for you all to consider. Is there really one type of Ad-hoc Reporting with Qlik Sense? Read-on to learn how you can "Ad-hoc"  with Qlik Sense!