1 2 3 Previous Next

Qlik Design Blog

499 posts

Did you know there's a secret developer menu in Qlik Sense? I'm going to let you in on the secret and show you how to access it and what it contains. Just remember, this isn't documented or officially supported, and is subject to change in the future.


To access the developer menu, follow the steps below:


  1. Open a sheet in a Qlik Sense app in your browser
  2. Add /options/developer to the url
  3. Right click on an object and choose "Developer"



You can get the object id, properties, and layout of any object this way. There's also a link to open the object in single configurator, and test exporting. The object id's are useful for embedding visualizations. The properties are useful if you are creating your own objects and want to check the properties of an object in a Qlik Sense app for reference. In my opinion this is the most useful feature of the developer menu. Sometimes if I don't know the correct properties to set to achieve what I want I'll create a similar object in the Qlik Sense client just to check the properties. The layout shows what is returned by the engine for the layout of the object, and can be useful to see what the layout will look like before you actually create an object yourself. And the single configurator link is a handy way to get to the single configurator of an object directly from a sheet.




And now you know about the secret developer menu.

Hey Guys - this particular post may not be relevant to everyone, yet it is an integral part of making sure that a software's capabilities can be used by those who have impairments. With the release of Qlik Sense June 2018, we have added some new accessibility conformance features that comply with WCAG 2.0 standards.  To learn how we are making Qlik Sense more accessible to everyone, please check out this brief video below. Please let us know what you think and post any question, I'll be happy to address them.



Qlik Sense Accessibility




Michael Tarallo (@mtarallo) | Twitter



Can't see the video? YouTube blocked by your region or organization? Download the .mp4 to watch on your computer or mobile device.

Jennell McIntire

Age Function

Posted by Jennell McIntire Jul 13, 2018

In this blog I thought I would share the Age function – a function that is not new to Qlik Sense or QlikView but new to me.  The Age function, which can be used in the script or in a chart expression, returns the age or the number of “completed years” based on a given date (timestamp in the syntax below) and a birthdate (date_of_birth in the syntax below).  The syntax for the Age function is as follows:


age(timestamp, date_of_birth)


Based on the timestamp value, the Age function will return the number of full years that have passed since the date_of_birth.  Let’s look at a few examples.  In the table below, there are 5 players along with their birthdate.  In the last column, I am calculating their age using the Age function.  I am using the Today() function for the first parameter – this will return the current date (7/13/2018) from the system clock.  The second parameter is the birthdate (a field in the data model) for the player.


Notice that the date format for the current date and Birthdate are the same.  The format of dates in an app are based on the Set DateFormat statement at the beginning of the load script unless you opt to format them differently.  In this example, the DateFormat is set as follows:


If I try to calculate the age based on the expression below, it will not work because the first parameter is not formatted properly based on the DateFormat (M/D/YYYY) I am using in the app.  In this case, the Age function will return null.


Age can also be calculated based on a date other than the current date.  For instance, I can calculate age based on an event or the last day of the year.  The Age function is a very simple function to use and can be used in various scenarios other than age to calculate the number of years that have passed since a given date.




I have blogged about qdt-components in the past, on how we can use it with Angular, React, Vue and simple html in the past.


Today I will focus on the Wordpress version.


We can start by searching for the plugin. You can type "Qlik" or "qdt" and you will see it in the results



Once installed, go to the settings and add your server configuration



Then, you can go ahead and create your page/post and add the shortcodes. So far, the only available ones are for KPIs and embedding visualizations.


[qdt-component type="QdtKpi" expr="=Num(Count(distinct operation_id), '###,###')"]
[qdt-component type="QdtViz" id="sNMsjYL" height="400px"]


Here is how it should like at the end



Coming up: All of the features in qdt-components

React template with qdt-components


Github: https://github.com/qlik-demo-team/qdt-wordpress-plugin



If you follow this blog then you know that during the last weeks we’ve been working in our Choose your champion app for the FIFA World Cup tournament happening in Russia.


Our data provider, Gracenote, populates and periodically updates several tables in a SQL database with all the tournament data.


As an example, just assume the Players table looks like this:




Player A


Player B


Player C



The field Actions contain “compressed” information for 8 different actions during a game. The value 145 encapsulates all the information about Player A's performance during a certain game.


Combining multiple values into a single field


It is a frequent practice to combine multiple flag or binary columns into a single decimal column, instead of creating multiple columns to store these indicators.


One of the main advantages of this system versus the alternative of creating a column for each one of the actions is that if later we decide to record a new type of action we can just add it to the Actions column versus having to create a new column for each field.


But, how can I read what Actions column content actually means?


To do so we need more information. We need to know how that column is being created. For example, let’s assume we have this description of Actions column:


Actions Legend

game played = 1

goal scored = 2

penalty scored = 4

penalty missed = 8

1st yellow card = 16

2nd yellow card = 32

red card = 64

assists = 128


The above's data is the key to understand what’s stored in the Action column. To get a better view of it, let's convert the base 10 integer “Value”, to binary as in the expanded representation table below:



Player A (145)

Player B (17)

Player C (139)

Game played (1)




Goal scored (2)




Penalty scored (4)




Penalty missed (8)




1st yellow card (16)




2nd yellow card (32)




Red card (64)




Assist (128)





Binary flags representation:





Player A



Player B



Player C






Player A: played the game, got a yellow card and gave an assist to other player to score a goal.

Player B: played the game and got a yellow.

Player C: played the game, scored a goal, missed a penalty and assisted for a goal.


How to find what we are looking for?


To do so, it’s important to familiarize with the available bitwise or bit operators in Qlik:


Bitnot, bitand, bitor, bitxor , >>, <<


For more examples and further explanation you can check this page: https://en.wikipedia.org/wiki/Bitwise_operation


Continuing with the example, let’s try to find players that have scored a goal.


We need to check if the second bit is set, that means 00000010 (or integer 2 in base 10)




Value bitand 2

Player A



Player B



Player C




From PlayerTable where Value bitand 2 >0;


That statement is selecting from PlayerTable where Value bitand 2 > 0. But, let's go row by row to see what's happening under the hood:

A bitwise AND takes two equal-length binary representations and performs the logical AND operation on each pair of the corresponding bits, by multiplying them. Thus, if both bits in the compared position are 1, the bit in the resulting binary representation is 1 (1 × 1 = 1); otherwise, the result is 0 (1 × 0 = 0 and 0 × 0 = 0)


Player A

        10010001 (145 decimal)

bitand  00000010 (2 decimal)


returns 00000000 (0 decimal)


Player B

        00010001 (17 decimal)

bitand  00000010 (2 decimal)


returns 00000000 (0 decimal)


Player C

        10001011 (139 decimal)

bitand  00000010 (2 decimal)


returns 00000010 (2 decimal)



Find the players who received a “Yellow Card” and did not “Assist”

We need to check if the fifth bit is set,  00010000 (or integer 16 in base 10) and if the eight bit is not set (128 base 10)



Value bitand 16

Value bitand 128

Player A




Player B




Player C





From PlayerTable where Value bitand 16 > 0 and Value bitand 128 = 0;



Bit operators in expressions


Remember you can use the bit operators to create expressions too, so in a object we could do:


=count(distinct {<Value = {"=Value bitand 16 > 0"}>} Player)


This counts how many players have seen a yellow card so far, note how we are comparing the Value with the flag yellow card (16).


As you can see in the examples, the use of the bitand operator has allowed us to compare two different values at a binary level and returns whether the two numbers intersect allowing me to select and/or count the correct numbers.


Hope you find this interesting.

Arturo (@arturoqv)


PS: I'm attaching a QlikView and Qlik Sense app with the example data so you can test it out yourselves.


The biggest tournament in soccer is in full swing today, and if you haven't checked out our Choose Your Champion demo app, take a second to check it out now Choose Your Champion. We've gotten some questions about how we built it, so I'm going to go through a high-level summary. Before we begin, note that there's really two parts of the Choose Your Champion app, the Create a Bracket part, and the Historical Analysis part, which we really took two different approaches for.





Create a Bracket

For the “Create a Bracket” half of the Choose Your Champion app, we connect to a Qlik Sense app with enigma.js on page load. We get all the data we need from Qlik Sense using Qlik expressions and pagination to select from the associated data, which is fast and easy. The data we get from Qlik Sense we then put into a Redux store, and manage state from there. We decided this was the best approach for this part of the app for us for quite a few reasons, but it would be pretty trivial to have Qlik Sense manage all the state here if desired with a few Qlik Sense variables and a bit of set analysis.


Once we have the data from Qlik Sense saved in a Redux store, we just use html, css, and javascript to build the bracket and charts. Any selections the user makes just updates the Redux store. The charts here really are very simple, just some divs with conditional widths/heights. We allow the user to authenticate with Facebook and save their bracket, which we just save to a database, and fallback to localstorage to save the state if the user isn’t authenticated or hasn’t yet saved a bracket.


And this really demonstrates the power and flexibility of Qlik Sense APIs. We can easily get the data we need, and then do whatever we’d like with it.



historical.pngHistorical Analysis

The “Historical Analysis” half of the Choose Your Champion app is probably a more familiar Qlik Sense experience. We connect to the app using our qdt-components library so we have access to our prebuilt QdtSelectionToolbar component and then also built a custom filter and table component (fun fact: the bar chart is also the custom table component, with a few special props). We also connect to the Visualization API using qdt-components to create and embed some native Qlik Sense visualizations.


That’s really it, this part of the app is pretty straightforward.


A few comments

Somebody had asked if the custom visualizations were extensions, and the answer is no, there are no extensions used here. While Qlik Sense extensions are great if you want to reuse them across multiple apps, or enable non-developers to create the objects in the Qlik Sense client, if you don’t have those requirements it’s easier to just build some components that interface with the Qlik Sense engine but don’t have to worry about being extensions. This also means those components can be used in other projects where you may not be connecting to the Visualization API and you won’t have to load all of the assets required to use the Visualization API.


And that’s it. Like I already stated, I think this demo shows the power and flexibility of the Qlik Sense APIs and what is possible with them, and I hope there’s something to take away for everyone here. If you guys have any questions about any of it, let me know.

Michael Tarallo

Using IntervalMatch()

Posted by Michael Tarallo Jun 12, 2018


Hey guys, I was recently at a user group meeting and the topic of IntervalMatch() came up with regards to when and where it was best used. I liked the topic and subject matter that was covered, so I decided to create a quick video showing you how I used it when rating or grading some video game consoles. Note that IntervalMatch() can be used in many situations, however there may be other approaches to achieve similar results. View the Qlik Help topic here.





IntervalMatch is a data load script prefix that creates and links a table used for matching discrete numeric values to one or more numeric intervals where there may not be any specific link or key available between the tables. This is used in situations that utilize interval scales of data such as population, date ranges, temperature, number of units, scoring etc. to name a few.


Let’s imagine I have a number of video game consoles that vary in condition. I want to assign them a rating from good to worst based on a numeric scale related to overall condition and function. I have a grading table that contains the numeric ranges for the grade as follows. Note the Grade field description and the High and Low field range values.


6-12-2018 1-15-24 PM.png


I also have a table that contains my consoles names and their individual rating numeric value.


6-12-2018 1-15-40 PM.png



Since these two tables don’t have a common link between them, when the data is loaded and I select a value from either the console or the grade lists, I cannot see any of the relationships.


6-12-2018 2-17-57 PM.png



I can easily solve this using the IntervalMatch prefix which will look at the data already loaded from the grade table with the numeric intervals and match it to the Rating field in the consoles tables. IntervalMatch must come after the initial data is loaded and before the load statement as shown. (Please note that your interval field order is important, starting with the field containing the lowest interval value first.)


[Grade Ranges]:
FROM [lib://AttachedFiles/console_grades.xlsx]
(ooxml, embedded labels, table is [Grade Ranges]);

[Console Rating]:
FROM [lib://AttachedFiles/console_grades.xlsx]
(ooxml, embedded labels, table is [Console Rating]);

[interval match table]:
Resident [Grade Ranges]


Upon loading the data – you can now see that the tables are now linked with this new interval table. Technically a synthetic key is created but in this situation I am told it is nothing to be concerned about. Now you can clearly see the grade of my consoles by either selecting the Grade or the Console list values or within the table visualization.


6-12-2018 2-22-02 PM.png6-12-2018 2-22-16 PM.png


As always there usually is more than one solution to these types of problems, and perhaps some may be more optimal than others. I’d love to hear from you, so if you have another approach please share it with us.



Mike Tarallo
@mtarallo - Twitter


Can't see the video? YouTube blocked by your region or organization? Download the attached .mp4 to view on your computer or mobile device.

One of the new features in the April 2018 release of Qlik Sense was the addition of the NumericalAbbreviation variable.  This variable allows users to specify the numeric abbreviations that are used when a numeric value has an Auto number format.  This was great because by default, G is used to indicate billions and my preference is to use B.  Now, I can do that by editing the NumericalAbbreviation variable in my script.  If you are familiar with scripting, you know that the first few lines on the Main tab in the script are SET variable statements that indicate what abbreviations and values you would like to use to represent certain data in your app.  For example, in the script below, the MonthNames variable is set to how I would like to abbreviate months in my app.

SET month.png

With the NumericalAbbreviation variable, I can specify how I will like the numeric abbreviation to appear.  By default, it is set like this:

SET default.png

If you created an app using a release prior to the April 2018 release, you will not see this variable on the Main tab in your script but you can add it to your script along with the other variables statements.  The easiest way to do this is to copy and paste it from Qlik Help.


In the app screenshot below, you can see the G used in the Total Gross KPI and in the Top 10 Theaters bar chart (bottom left).


Since my preference is to use the B instead of G to show billions, I changed the NumericalAbbreviation variable to be:

SET - Copy.png

Now the app looks like this:


A small, easy tweak to the script, allowed me to change the numeric abbreviation in the app.  I should note that the numeric abbreviation is used only when Numbering Format is set to Auto.  So, if the Numbering Format is set to something other than Auto such as Money or Number, the NumericAbbreviation variable is not used and the format that you specify in the properties of the object is used.


In this blog, I showed one example of how the NumericalAbbreviation variable can be used but it can also be used to add spacing before the abbreviation or other custom abbreviations, if you choose.  This seems like a small feature but it has a large impact providing users with more flexibility and control over how the data is displayed.  To learn about other new features released in April, check out Michael Tarallo’s Qlik Sense – What’s New April 2018 video.




martin.pngHey guys! I'm pleased to introduce our newest guest presenter in the Qlik Design Blog, Martin Tombs, Global Pre Sales Director at Qlik. Martin has created a video presentation (embedded and attached below) which will help our partners learn how to take advantage of our Qlik Technical Sales Tools - recently announced at Qonnections. I had a chance to view this video in greater detail to prepare the intro and body of this blog - and it is absolutely amazing what the Pre-Sales organization has assembled AND now made available to our partner community!


If you are a Qlik partner, I highly recommenced you invest the 20+ mins to review this presentation and demonstration video. These tools are now being opened up to our partners as a way to facilitate self-sufficiency during the professional phase of the sales cycle.


Qlik Technical Sales Tools can be accessed from the Qlik Partner Portal and currently consists of:


  • Presentation Explorer - Online Qlik application, including 400+ slides & speaker notes, search and build your presentation
  • Technical Insights - Search for answers to questions, samples questions with contextual answers and articles - great for RFPs
  • Sizing Advisor - Online Qlik tool used to deliver hardware recommendations with PDF report generation
  • Qlik Machine Images (QMI) - Automation for demonstration within personal environments of many Qlik product scenarios




Can't see the video? YouTube blocked by your organization or region? Don't fret, download the .mp4 file to watch on your computer or mobile device.


I'd like to thank Martin and the Qlik Pre-Sales organization for sharing this remarkable resource. Please post comments and questions below, we want to hear from you - myself and our team will do our best to respond. Take care all.



Mike Tarallo



I have talked about about qdt-components in the past and how it can be used with Angular, React and in a simple html page.

qdt-components - A Components Library that can be used in simple Html, Angular 5 and React

Today I will show you how to use it with Vue.js.


You can start by the template that we put together https://github.com/qlik-demo-team/qdt-vue-template.


The main component is the QdtComponent.vue https://github.com/qlik-demo-team/qdt-vue-template/blob/master/src/components/QdtComponent.vue


import QdtComponents from 'qdt-components';
const options = {
  config: {
    host: '<yourserver.com>',
    secure: true,
    port: 443,
    prefix: '',
    appId: '133dab5d-8f56-4d40-b3e0-a6b401391bde',
  connections: {
    vizApi: true,
    engineApi: true,
const qdtComponents = new QdtComponents(options.config, options.connections);
export default {
  name: 'QdtComponent',
  props: {
    type: String,
    props: Object,
  mounted() {
    qdtComponents.render(this.type, this.props, this.$el);


Then you can create your pages and start adding your visualizations.


To embed a simple Qlik Sense chart just add this line

<QdtComponent :type="viz2.type" :props="viz2.props"  />

Where viz2 is

const viz2 = {
  type: 'QdtViz',
  props: {
    type: 'barchart', id: 'a5e0f12c-38f5-4da9-8f3f-0e4566b28398', height: '300px',


The full example is at



and you can view it live at



More posts on qdt-components

qdt-components - Horizontal Barchart by Picasso.js & Selection Toolbar

Qdt-components & Picasso.js - More Charts!


This is it


Our David Freriks is back introducing a free, open source utility that provides a visual exploration front end that helps you understand the “big data” that exists inside the Cloudera data lake. It allows a user to visually understand how to create fully interactive Qlik apps on the data of interest to them.


Cloudera Data Lake Explorer is Qlik Associative Engine API based application that leverages metadata from Cloudera (Impala, Navigator, Manager) to browse the width of the data lake and build a self-service Qlik Sens application with no scripting required.  The explorer interface uses the power of the Qlik Associative Engine to show how all the metadata correlates between databases, tables, columns, metadata tags, and sql queries. Watch the video below to learn more.


This application has been published to Qlik Branch (http://branch.qlik.com/#!/project/5afb0d76fefa01686177560d ) and is hosted on Github. The Cloudera Data Explorer is a new take on how to use the power of Qlik to navigate, understand, and leverage big data in a way that simplifies the experience for the exploratory user.




David Freriks (@dlfreriks) | Twitter




David is a Technology Evangelist on the Innovation and Design team at Qlik. He has been working in the "big data" space for over three years, starting with Hadoop and moving onto Spark in this continuously evolving ecosystem. He has 18+ years in the BI space, helping launch new products to market.

Football season is almost over, only the Champions League winner is undecided yet, but soon the fútbol - football, soccer -  aficionado’s eyes will turn to this summer's tournament. Honestly, I can’t wait, this is the competition we all have been patiently waiting for the last four years. A long wait, especially if your team had a very disappointing tournament last time. No, it wasn’t a good 2014 World Cup for Spain.


If you are anything like me, you’d probably have already memorized each group’s teams, imagined any possible what-if scenario, and visualized your team’s captain getting that gorgeous golden trophy by July the 15th. We want to help you to take your guesses to the next level, and have a little bit of fun and competition.


Choose your Champion app will let you predict how this summer’s competition will finish, and more.




How it works


Our bracket is bit more sophisticated that most, we have created a data-driven experience. Each one of the decision points in the app has been enhanced with data, so when you pick a team to end up in the first place of a group, you can corroborate if your gut feeling matches with our data predictions. If you are doubtful about a knockout game winner simply check the stats and make an informed decision.


The process is simple, select first and second place in the groups stage, the bars next to the team names will tell you who is more likely to move to the next stage. Then in knockout round, check the gauge and the extended stats and pick the winner of each match to complete the bracket. Finally decide your tournament winner, and share it with your friends.


But there’s more


This year, we also want you to be able to track your bracket and check how do you rank among other people.


We added a simple login system using Facebook - no, we are not getting any of your personal data, not even your Facebook name nor email - and now you will be able to submit and save your bracket safely.  After the tournament have started, we will provide each one of you with a score based on how many predictions you got right.


You can use the Choose Your Champion score to compete against your friends and coworkers privately and beat them all!




Enjoy and share it!


If you want to use data from a hypercube to create a chart with picasso.js you're probably going to want to use the picasso.js q plugin. The q plugin makes it easy to extract data from a hypercube for use with picasso.js. In this post I'm going to go through the steps needed to use the q plugin for picasso.js to show you how to use hypercube data to create a chart with picasso.js, and also go over updating the chart when the hypercube data changes, and making selections in the QIX Engine from a picasso.js chart.


picasso.js scatter plot with hypercube data.png

Check out this observable notebook of creating a scatter plot with hypercube data and the q plugin

Setup picasso.js

You'll need to install picasso and picassoQ, and register picassoQ with picasso. You can install them with npm install --save picasso.js picasso-plugin-q, and then register picassoQ with picasso like below.

import picasso from 'picasso.js';
import picassoQ from 'picasso-plugin-q';

picasso.use(picassoQ); // this registers the picasso q plugin with picasso.js


Create and update picasso.js chart with hypercube data

You'll need a hypercube of course. I'm going to assume here that you know how to create a hypercube with the App API or enigma.js, and if not, there's other resources for learning how to do that, so we won't cover it again here. Below is a general pattern for creating and updating a picasso.js chart after creating a hypercube with enigma.js

(async () => {
const hypercube = await qDoc.createSessionObject(/* hypercube def */);
const layout = await hypercube.getLayout();
createPic(layout); // function that calls chart method on a picasso instance
hypercube.on('changed', async () => {  // listen for updates to hypercube
    const newLayout = await hypercube.getLayout();  // get new layout
    updatePic(newLayout); // function that calls update method on a picasso instance


In the above block, we create a hypercube, get the layout, and call a function we define that calls the chart method on an instance of picasso.js. Then we watch for the hypercube to update, and can use the update method of picasso.js to simply update the data for the chart. The createPic and updatePic functions might look something like this.

let chart;
const createPic = (layout) => {
chart = picasso().chart({
   element: document.querySelector('#container'), // some DOM element
   data: [{
     type: 'q', // this tells picasso the data is from a hypercube
     key: 'qHyperCube', // path to the hypercube from the layout,
     data: layout.qHyperCube
   settings: {} // the chart settings (scales, components, etc.)

const updatePic = (layout) => {
chart.update({ // we just need to update the data
    data: [{
     type: 'q',
     key: 'qHyperCube',
     data: layout.qHyperCube


Making selections in the QIX engine

The picasso q plugin has helper functions for generating methods to make QIX selections from a picasso.js brush. You just get a reference to the brush using the brush method of picasso, then use the selections method of picassoQ to generate the QIX methods, then apply them to your QIX model. It would look something like this.

const brush = chart.brush('name-of-brush'); // get reference to brush
const selection = picassoQ.selections(brush)[0]; // generate selection method
qDoc[selection.method](...selection.params); // apply selection method to model



And that's it. You can check out the observable notebook I created for this blog post, and the picasso-plugin-q too.

Hi folks - this video will show you how to get started with Qlik Sense Mobile from a basic sense. There have been some signifcant changes since I last recorded a video on this and it was time for a brief update. Due note that we have much more for those of you who administer, secure and deploy mobile BI. We work with Enterprise Mobile management vendors to tightly integrate our solution with their platforms. See the resource links below.


In this video you will learn how to:


  • Install the Qlik Sense Mobile App on iOS
  • Configure and Send Client Authentication Link Using the QMC
  • Verify Offline Security Settings
  • Start the app and login to your server
  • Download your app
  • Access your app offline


Note: Offline access via the Qlik Sense Mobile App is only available to Qlik Sense Enterprise customers. However, Qlik Sense servers and Qlik Sense Cloud can be quickly and easily accessed via a mobile device such as a tablet or smart phone by simply using a mobile browser that supports HTML5 - i.e. Chrome, Safari, etc. Check out these 2 videos to learn more:


Please let me know if you have any comments or questions.



Qlik Sense Mobile







Michael Tarallo (@mtarallo) | Twitter


Can't see the embedded video? YouTube blocked by your organization or region? Download the .mp4 to watch on your computer or mobile device.

layout.pngHey guys - I recently was inspired at Qonnections 2018 by our Big Data Qlik IoT Race game, so much so that I had to understand how it all worked and wanted to play with the underlying technology. Aside from gathering the statistics and providing an analysis on the results, I was really interested in learning about those little devices or "things" that were connected to the track. However, how would I use something like that? Not really knowing anything about Arduino, WEMOS and IoT in general, I set out on a mission to learn about this fascinating technology while incorporating somethings I enjoy such as Qlik and retro-gaming. Take a look how I made IoT interesting and fun to learn, by incorporating a Retrogaming spin and of course added some Qlik Sense data analysis.



5-9-2018 9-47-26 PM.png

Atari Action Analysis Dashboard




Thanks guys, hope you enjoyed it. Let me know what you think by leaving your questions and comments. I'll do my best to respond.


Can't see the video? YouTube blocked by your region or organization?


A copy of the video can be downloaded or streamed from here:



Michael Tarallo (@mtarallo) | Twitter

Filter Blog

By date:
By tag: