google analysis

How Page Value is calculated

At a glance

Page Value is the average value for a page that a user visited before landing on the goal page or completing an Ecommerce transaction (or both). This value is intended to give you an idea of which page in your site contributed more to your site’s revenue. If the page wasn’t involved in an ecommerce transaction for your website in any way, then the Page Value for that page will be $0 since the page was never visited in a session where a transaction occurred.

Below is the equation you can follow to calculate Page Value. Please note that the unique pageview statistic represents the number of individual users who have loaded a given page per session. Each user is counted only once per session, no matter how many pages are opened by the same user.

Ecommerce Revenue + Total Goal Value Number of Unique Pageviews for Given Page

In depth

The first example above illustrates how Page Value works. Let’s say you want to know the Page Value for Page B, and you know the following factors:

Goal page D: $10 (Remember, you assign the value of the Goal page when you first create a goal in the Analytics Settings page) Receipt Page E: $100 (This page is where the user makes an ecommerce transaction of $100) Unique pageview for Page B: One

You would then set up your Page Value equation like this:

Ecommerce Revenue ($100) + Total Goal Value ($10) Number of Unique Pageviews for Page B (1)

Page Value for Page B is $110 since a user visits Page B only once before the goal page during this session.

Now let’s explore how Page Value for Page B is affected when we combine the data from two different sessions. You can see that Page B is viewed only once during Session 1, but during Session 2 it gets two pageviews (we’re assuming the two pageviews are from the same user). The total Ecommerce revenue stays the same during both sessions. Although there were two unique pageviews, there was still only one Ecommerce transaction total for both sessions.

Goal page D: $10 Receipt Page E: $100 Unique pageview for Page B: Two

Your Page Value calculation should be adjusted to look like this:

Ecommerce Revenue ($100) + Total Goal Value ($10 x 2 sessions) Number of Unique Pageviews for Page B (2)

Page Value for Page B across two sessions is then $60, or $120 divided by two sessions.

Code snippet about setting up GA in your site

```html

                    var hostName = window.location.host;
                            var ga_script = document.createElement('script');
                                    ga_script.setAttribute('async',true);
                                            if (['localhost:9000','test','uat'].some(function(hostItem){return hostName.indexOf(hostItem)>-1})) {
                                                            // non-production
                                                                        ga_script.setAttribute('src','https://www.google-analytics.com/analytics_debug.js');
                                                                                    window.ga_debug = {trace: true};
                                                                                            }else {
                                                                                                            ga_script.setAttribute('src','https://www.google-analytics.com/analytics.js');
                                                                                                                    }
                                                                                                                            document.head.appendChild(ga_script);
                                                                                                                                    ga('send', 'pageview');
                                                                                                                                        </script>
                                                                                                                                        ```

                                                                                                                                        ```javascript
                                                                                                                                        $rootScope.$on('$stateChangeSuccess', function() {
                                                                                                                                                            $window.ga('send', 'pageview', $location.path());
                                                                                                                                                                            $window.scrollTo(0, 0);
                                                                                                                                                                                        });
                                                                                                                                        ```


                                                                                                                                        Alternative async tracking snippet
                                                                                                                                        While the JavaScript tracking snippet described above ensures the script will be loaded and executed asynchronously on all browsers, it has the disadvantage of not allowing modern browsers to preload the script.
                                                                                                                                        The alternative async tracking snippet below adds support for preloading, which will provide a small performance boost on modern browsers, but can degrade to synchronous loading and execution on IE 9 and older mobile browsers that do not recognize the async script attribute. Only use this tracking snippet if your visitors primarily use modern
                                                                                                                                        browsers to access your site.

                                                                                                                                        <!-- Google Analytics -->
                                                                                                                                        <script>
                                                                                                                                        window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)};ga.l=+new Date;
                                                                                                                                        ga('create', 'UA-XXXXX-Y', 'auto');
                                                                                                                                        ga('send', 'pageview');
                                                                                                                                        </script>
                                                                                                                                        <script async src='https://www.google-analytics.com/analytics.js'></script>
                                                                                                                                        <!-- End Google Analytics -->

                                                                                                                                        From <https://developers.google.com/analytics/devguides/collection/analyticsjs/> 
                                                                                                                                        What data does the tracking snippet capture?
                                                                                                                                        When you add either of these tracking snippets to your website, you send a pageview for each page your users visit. Google Analytics processes this data and can infer a great deal of information including:
                                                                                                                                        • The total time a user spends on your site.
                                                                                                                                        • The time a user spends on each page and in what order those pages were visited.
                                                                                                                                        • What internal links were clicked (based on the URL of the next pageview).
                                                                                                                                        In addition, the IP address, user agent string, and initial page inspection analytics.js does when creating a new tracker is used to determine things like the following:
                                                                                                                                        • The geographic location of the user.
                                                                                                                                        • What browser and operating system are being used.
                                                                                                                                        • Screen size and whether Flash or Java is installed.
                                                                                                                                        • The referring site.

                                                                                                                                        From <https://developers.google.com/analytics/devguides/collection/analyticsjs/#alternative_async_tracking_snippet> 


                                                                                                                                        How analytics.js Works

                                                                                                                                        From <https://developers.google.com/analytics/devguides/collection/analyticsjs/how-analyticsjs-works> 

                                                                                                                                        The ga command queue
                                                                                                                                        The JavaScript tracking snippet defines a global ga function known as the "command queue". It's called the command queue because rather than executing the commands it receives immediately, it adds them to a queue that delays execution until the analytics.js library is fully loaded.
                                                                                                                                        In JavaScript, functions are also objects, which means they can contain properties. The tracking snippet defines a q property on the ga function object as an empty array. Prior to the analytics.js library being loaded, calling the ga() function appends the list of arguments passed to the ga()function to the end of the q array.
                                                                                                                                        For example, if you were to run the tracking snippet and then immediately log the contents of ga.qto the console, you'd see an array, two items in length, containing the two sets of arguments already passed to the ga() function:

                                                                                                                                        console.log(ga.q);

                                                                                                                                        // Outputs the following:
                                                                                                                                        // [
                                                                                                                                        //   ['create', 'UA-XXXXX-Y', 'auto'],
                                                                                                                                        //   ['send', 'pageview']
                                                                                                                                        // ]
                                                                                                                                        Once the analytics.js library is loaded, it inspects the contents of the ga.q array and executes each command in order. After that, the ga() function is redefined, so all subsequent calls execute immediately.
                                                                                                                                        This pattern allows developers to use the ga() command queue without having to worry about whether or not the analytics.js library has finished loading. It provides a simple, synchronous-looking interface that abstracts away most of the complexities of asynchronous code.

                                                                                                                                        From <https://developers.google.com/analytics/devguides/collection/analyticsjs/how-analyticsjs-works> 

                                                                                                                                        Adding commands to the queue
                                                                                                                                        All calls to the ga() command queue share a common signature. The first parameter, the "command", is a string that identifies a particular analytics.js method. Any additional parameters are the arguments that get passed to that method.
                                                                                                                                        The method a particular command refers to can be a global method, like create, a method on the ga object, or it can be an instance method on a tracker object, like send. If the ga() command queue receives a command it doesn't recognize, it simply ignores it, making calls to the ga()function very safe, as they will almost never result in an error.
                                                                                                                                        For a comprehensive list of all commands that can be executed via the command queue, see the ga() command queue reference.

                                                                                                                                        From <https://developers.google.com/analytics/devguides/collection/analyticsjs/how-analyticsjs-works> 

                                                                                                                                        Command parameters
                                                                                                                                        Most analytics.js commands (and their corresponding methods) accept parameters in a number of different formats. This is done as a convenience to make it easier to pass commonly used fields to certain methods.
                                                                                                                                        As an example, consider the two commands in the JavaScript tracking snippet:

                                                                                                                                        ga('create', 'UA-XXXXX-Y', 'auto');
                                                                                                                                        ga('send', 'pageview');
                                                                                                                                        In the first command, create accepts the fields trackingId, cookieDomain, and name to optionally be specified as the second, third, and fourth parameters, respectively. The sendcommand accepts an optional hitType second parameter.
                                                                                                                                        All commands accept a final fieldsObject parameter that can be used to specify any fields as well. For example, the above two commands in the tracking snippet could be rewritten as:

                                                                                                                                        ga('create', {
                                                                                                                                              trackingId: 'UA-XXXXX-Y',
                                                                                                                                                cookieDomain: 'auto'
                                                                                                                                        });
                                                                                                                                        ga('send', {
                                                                                                                                              hitType: 'pageview'
                                                                                                                                        });
                                                                                                                                        See the ga() command queue reference for a comprehensive list of the optional parameters allowed for each of the commands.

                                                                                                                                        From <https://developers.google.com/analytics/devguides/collection/analyticsjs/how-analyticsjs-works> 


                                                                                                                                        Creating Trackers
                                                                                                                                        • Contents
                                                                                                                                        • The create method
                                                                                                                                        • Naming trackers
                                                                                                                                        • Specifying fields at creation time
                                                                                                                                        • Working with multiple trackers
                                                                                                                                        • Running commands for a specific tracker
                                                                                                                                        • Next steps
                                                                                                                                        Tracker objects (also known as "trackers") are objects that can collect and store data and then send that data to Google Analytics.
                                                                                                                                        When creating a new tracker, you must specify a tracking ID (which is the same as the property ID that corresponds to one of your Google Analytics properties) as well as a cookie domain, which specifies how cookies are stored. (The recommended value 'auto' specifies automatic cookie domain configuration.)
                                                                                                                                        If a cookie does not exist for the specified domain, a client ID is generated and stored in the cookie, and the user is identified as new. If a cookie exists containing a client ID value, that client ID is set on the tracker, and the user is identified as returning.
                                                                                                                                        Upon creation, tracker objects also gather information about the current browsing context such as the page title and URL, and information about the device such as screen resolution, viewport size, and document encoding. When it's time to send data to Google Analytics, all of the information currently stored on the tracker gets sent.

                                                                                                                                        From <https://developers.google.com/analytics/devguides/collection/analyticsjs/creating-trackers> 

                                                                                                                                        Running commands for a specific tracker
                                                                                                                                        To run analytics.js commands for a specific tracker, you prefix the command name with the tracker name, followed by a dot. When you don't specify a tracker name, the command is run on the default tracker.
                                                                                                                                        To send pageviews for the above two trackers, you'd run the following two commands:

                                                                                                                                        ga('send', 'pageview');
                                                                                                                                        ga('clientTracker.send', 'pageview');
                                                                                                                                        Future guides will go into more detail on the syntax for running specific commands. You can also refer to the command queue reference to see the full command syntax for all analytics.js commands.

                                                                                                                                        From <https://developers.google.com/analytics/devguides/collection/analyticsjs/creating-trackers> 

                                                                                                                                        Getting trackers via ga Object methods
                                                                                                                                        If you're not using a default tracker, or if you have more than one tracker on the page, you can access those trackers via one of the ga object methods.
                                                                                                                                        Once the analytics.js library is fully loaded, it adds additional methods to the ga object itself. Two of those methods, getByName and getAll, are used to access tracker objects.
                                                                                                                                        Note: ga object methods are only available when analytics.js has fully loaded, so you should only reference them inside a ready callback.
                                                                                                                                        getByName
                                                                                                                                        If you know the name of the tracker you want to access, you can do so using the getByNamemethod:

                                                                                                                                        ga('create', 'UA-XXXXX-Y', 'auto', 'myTracker');

                                                                                                                                        ga(function() {
                                                                                                                                              // Logs the "myTracker" tracker object to the console.
                                                                                                                                                console.log(ga.getByName('myTracker'));
                                                                                                                                        });

                                                                                                                                        From <https://developers.google.com/analytics/devguides/collection/analyticsjs/accessing-trackers> 

                                                                                                                                        The last line of the JavaScript tracking snippet adds a send command to the ga() command queue to send a pageview to Google Analytics:

                                                                                                                                        ga('create', 'UA-XXXXX-Y', 'auto');
                                                                                                                                        ga('send', 'pageview');
                                                                                                                                        The object that is doing the sending is the tracker that was scheduled for creation in the previous line of code, and the data that gets sent is the data stored on that tracker.
                                                                                                                                        This guide describes the various ways to send data to Google Analytics and explains how to control what data gets sent.

                                                                                                                                        From <https://developers.google.com/analytics/devguides/collection/analyticsjs/sending-hits> 

                                                                                                                                        Hits, hit types, and the Measurement Protocol
                                                                                                                                        When a tracker sends data to Google Analytics it's called sending a hit, and every hit must have a hit type. The JavaScript tracking snippet sends a hit of type pageview; other hit types include screenview, event, transaction, item, social, exception, and timing. This guide outlines the concepts and methods common to all hit types. Individual guides
                                                                                                                                        for each hit type can be found under the section Tracking common user interactions in the left-side navigation.
                                                                                                                                            The hit is an HTTP request, consisting of field and value pairs encoded as a query string, and sent to the Measurement Protocol.

                                                                                                                                            From <https://developers.google.com/analytics/devguides/collection/analyticsjs/sending-hits> 

                                                                                                                                            The simplest way to use the send command, that works for all hit types, is to pass all fields using the fieldsObjectparameter. For example:

                                                                                                                                            ga('send', {
                                                                                                                                                  hitType: 'event',
                                                                                                                                                    eventCategory: 'Video',
                                                                                                                                                      eventAction: 'play',
                                                                                                                                                        eventLabel: 'cats.mp4'
                                                                                                                                            });
                                                                                                                                            For convenience, certain hit types allow commonly used fields to be passed directly as arguments to the sendcommand. For example, the above send command for the "event" hit type could be rewritten as:

                                                                                                                                            ga('send', 'event', 'Video', 'play', 'cats.mp4');
                                                                                                                                            For a complete list of what fields can be passed as arguments for the various hit types, see the "parameters" section of the send method reference.


                                                                                                                                            From <https://developers.google.com/analytics/devguides/collection/analyticsjs/sending-hits> 

2022

Minium Workable Mvp Vimrc

”—————————————————————- “ 4. User interface “—————————————————————- “ Set X lines to the cursor when moving vertically set scrolloff=0

Linux Tips

Remember, some things have to end for better things to begin.

Back to Top ↑

2021

How to user fire extinguisher

Summary As you know, staff and your safety is paramount. So what if emergency take place, such as fire in office, how to help yourself and your colleagues by...

Deep dive into Kubernetes Client API

Summary To talk to K8s for getting data, there are few approaches. While K8s’ official Java library is the most widely used one. This blog will look into thi...

Whitelabel Error Page

Summary Whitelabel Error Page is the default error page in Spring Boot web app. It provide a more user-friently error page whenever there are any issues when...

Google maps no photos reviews

Summary I found a weird problem of the app Google Maps of my Oppo Android phone. That’s when you search a place in Google map, say “Central Park”, ideally th...

Debts in a nutshell

A debt security represents a debt owed by the issuer to an investor. Here, the investor acts as a lender to the issuer which may be a government, organisatio...

Back to Top ↑

2020

Debug Stuck IntelliJ

What happened to a debug job hanging in IntelliJ (IDEAS) IDE? You may find when you try to debug a class in Intellij but it stuck there and never proceed, e....

Awesome Kotlin

Difference with Scala Kotlin takes the best of Java and Scala, the response times are similar as working with Java natively, which is a considerable advantag...

JVM热身

此文是作者英文原文的翻译文章,英文原文在:http://todzhang.com/posts/2018-06-10-jvm-warm-up/

Mock in kotlin

Argument Matching & Answers For example, you have mocked DOC with call(arg: Int): Intfunction. You want to return 1 if argument is greater than 5 and -1 ...

Mock in kotlin

Argument Matching & Answers For example, you have mocked DOC with call(arg: Int): Intfunction. You want to return 1 if argument is greater than 5 and -1 ...

Curl

Linux Curl command

AOP

The concept of join points as matched by pointcut expressions is central to AOP, and Spring uses the AspectJ pointcut expression language by default.

Micrometer notes

As a general rule it should be possible to use the name as a pivot. Dimensions allow a particular named metric to be sliced to drill down and reason about th...

Awesome SSL certificates and HTTPS

What’s TLS TLS (Transport Layer Security) and its predecessor, SSL (Secure Sockets Layer), are security protocols designed to secure the communication betwee...

JVM warm up by Escape Analysis

Why JVM need warm up I don’t know how and why you get to this blog. But I know the key words in your mind are “warm” for JVM. As the name “warm up” suggested...

Java Concurrent

This blog is about noteworthy pivot points about Java Concurrent Framework Back to Java old days there were wait()/notify() which is error prone, while fr...

Back to Top ↑

2019

Conversations with God

Feelings is the language of the soul. If you want to know what’s true for you about something, look to how your’re feeling about.

Kafka In Spring

Enable Kafka listener annotated endpoints that are created under the covers by a AbstractListenerContainerFactory. To be used on Configuration classes as fol...

Mifid

FX Spot is not covered by the regulation, as it is not considered to be a financial instrument by ESMA, the European Union (EU) regulator. As FX is considere...

Foreign Exchange

currency pairs Direct ccy: means USD is part of currency pair Cross ccy: means ccy wihtout USD, so except NDF, the deal will be split to legs, both with...

Back to Top ↑

2018

Guice

A new type of Juice Put simply, Guice alleviates the need for factories and the use of new in your Java code. Think of Guice’s @Inject as the new new. You wi...

YAML

Key points All YAML files (regardless of their association with Ansible or not) can optionally begin with — and end with …. This is part of the YAML format a...

Sudo in a Nutshell

Sudo in a Nutshell Sudo (su “do”) allows a system administrator to give certain users (or groups of users) the ability to run some (or all) commands as root...

Zoo-keeper

ZK Motto the motto “ZooKeeper: Because Coordinating Distributed Systems is a Zoo.”

Cucumber

Acceptance testing vs unit test It’s sometimes said that unit tests ensure you build the thing right, whereas acceptance tests ensure you build the right thi...

akka framework of scala

philosophy The actor model adopts the philosophy that everything is an actor. This is similar to the everything is an object philosophy used by some object-o...

Apache Camel

Camel’s message model In Camel, there are two abstractions for modeling messages, both of which we’ll cover in this section. org.apache.camel.Message—The ...

JXM

Exporting your beans to JMX The core class in Spring’s JMX framework is the MBeanExporter. This class is responsible for taking your Spring beans and registe...

Solace MQ

Solace PubSub+ It is a message broker that lets you establish event-driven interactions between applications and microservices across hybrid cloud environmen...

Apigee

App deployment, configuration management and orchestration - all from one system. Ansible is powerful IT automation that you can learn quickly.

Ansible

Ansible: What Is It Good For? Ansible is often described as a configuration management tool, and is typically mentioned in the same breath as Chef, Puppet, a...

flexbox

How Flexbox works — explained with big, colorful, animated gifs

KDB

KDB However kdb+ evaluates expressions right-to-left. There are no precedence rules. The reason commonly given for this behaviour is that it is a much simple...

Agile and SCRUM

Key concept In Scrum, a team is cross functional, meaning everyone is needed to take a feature from idea to implementation.

Strategy-Of-Openshift-Releases

Release & Testing Strategy There are various methods for safely releasing changes to Production. Each team must select what is appropriate for their own ...

NodeJs Notes

commands to read files var lineReader = require(‘readline’).createInterface({ input: require(‘fs’).createReadStream(‘C:\dev\node\input\git_reset_files.tx...

CORS :Cross-Origin Resource Sharing

Cross-Origin Request Sharing - CORS (A.K.A. Cross-Domain AJAX request) is an issue that most web developers might encounter, according to Same-Origin-Policy,...

ngrx

Why @Effects? In a simple ngrx/store project without ngrx/effects there is really no good place to put your async calls. Suppose a user clicks on a button or...

iOS programming

View A view is also a responder (UIView is a subclass of UIResponder). This means that a view is subject to user interactions, such as taps and swipes. Thus,...

Back to Top ↑

2017

cloud computering

openshift vs openstack The shoft and direct answer is `OpenShift Origin can run on top of OpenStack. They are complementary projects that work well together....

cloud computering

Concepts Cloud computing is the on-demand demand delivery of compute database storage applications and other IT resources through a cloud services platform v...

Redux

whats @Effects You can almost think of your Effects as special kinds of reducer functions that are meant to be a place for you to put your async calls in suc...

reactive programing

The second advantage to a lazy subscription is that the observable doesn’t hold onto data by default. In the previous example, each event generated by the in...

Container

The Docker project was responsible for popularizing container development in Linux systems. The original project defined a command and service (both named do...

promise vs observiable

The drawback of using Promises is that they’re unable to handle data sources that produce more than one value, like mouse movements or sequences of bytes in ...

JDK source

interface RandomAccess Marker interface used by List implementations to indicate that they support fast (generally constant time) random access. The primary ...

SSH SFTP

Secure FTP SFTP over FTP is the equivalant of HTTPS over HTTP, the security version

AWS Tips

After establishing a SSH session, you can install a default web server by executing sudo yum install httpd -y. To start the web server, type sudo service htt...

Oracle

ORA-12899: Value Too Large for Column

Kindle notes

#《亿级流量网站架构核心技术》目录一览 TCP四层负载均衡 使用Hystrix实现隔离 基于Servlet3实现请求隔离 限流算法 令牌桶算法 漏桶算法 分布式限流 redis+lua实现 Nginx+Lua实现 使用sharding-jdbc分库分表 Disruptor+Redis...

Java Security Notes

Java Security well-behaved: programs should be prevent from consuming too much system resources

R Language

s<-read.csv("C:/Users/xxx/dev/R/IRS/SHH_SCHISHG.csv") # aggregate s2<-table(s$Original.CP) s3<-as.data.frame(s2) # extract by Frequency ordered s3...

SSH and Cryptography

SFTP versus FTPS SS: Secure Shell An increasing number of our customers are looking to move away from standard FTP for transferring data, so we are ofte...

Eclipse notes

How do I remove a plug-in? Run Help > About Eclipse > Installation Details, select the software you no longer want and click Uninstall. (On Macintosh i...

Maven-Notes

Maven philosophy “It is important to note that in the pom.xml file you specify the what and not the how. The pom.xml file can also serve as a documentatio...

Java New IO

Notes JDK 1.0 introduced rudimentary I/O facilities for accessing the file system (to create a directory, remove a file, or perform another task), accessi...

IT-Architect

SOA SOA is a set of design principles for building a suite of interoperable, flexible and reusable services based architecture. top-down and bottom-up a...

Algorithm

This page is about key points about Algorithm

Java-Tricky-Tech-Questions.md

What is the difference between Serializable and Externalizable in Java? In earlier version of Java, reflection was very slow, and so serializaing large ob...

Compare-In-Java

Concepts If you implement Comparable interface and override compareTo() method it must be consistent with equals() method i.e. for equal object by equals(...

Java Collections Misc

Difference between equals and deepEquals of Arrays in Java Arrays.equals() method does not compare recursively if an array contains another array on oth...

HashMap in JDK

Hashmap in JDK Some note worth points about hashmap Lookup process Step# 1: Quickly determine the bucket number in which this element may resid...

Java 8 Tips

This blog is listing key new features introduced in Java 8

Back to Top ↑

2016

Java GC notes

verbose:gc verbose:gc prints right after each gc collection and prints details about each generation memory details. Here is blog on how to read verbose gc

Hash Code Misc

contract of hashCode : Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consis...

Angulary Misc

Dependency Injection Angular doesn’t automatically know how you want to create instances of your services or the injector to create your service. You must co...

Java new features

JDK Versions JDK 1.5 in 2005 JDK 1.6 in 2006 JDK 1.7 in 2011 JDK 1.8 in 2014 Sun之前风光无限,但是在2010年1月27号被Oracle收购。 在被Oracle收购后对外承诺要回到每2年一个realse的节奏。但是20...

Simpler chronicle of CI(Continuous Integration) “乱弹系列”之持续集成工具

引言 有句话说有人的地方就有江湖,同样,有江湖的地方就有恩怨。在软件行业历史长河(虽然相对于其他行业来说,软件行业的历史实在太短了,但是确是充满了智慧的碰撞也是十分的精彩)中有一些恩怨情愁,分分合合的小故事,比如类似的有,从一套代码发展出来后面由于合同到期就分道扬镳,然后各自发展成独门产品的Sybase DB和微...

浅谈软件单元测试中的“断言” (assert),从石器时代进步到黄金时代。

大家都知道,在软件测试特别是在单元测试时,必用的一个功能就是“断言”(Assert),可能有些人觉得不就一个Assert语句,没啥花头,也有很多人用起来也是懵懵懂懂,认为只要是Assert开头的方法,拿过来就用。一个偶然的机会跟人聊到此功能,觉得还是有必要在此整理一下如何使用以及对“断言”的理解。希望可以帮助大家...

Kubernetes 与 Docker Swarm的对比

Kubernetes 和Docker Swarm 可能是使用最广泛的工具,用于在集群环境中部署容器。但是这两个工具还是有很大的差别。

http methods

RFC origion http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.1.2)

Spark-vs-Storm

The stark difference among Spark and Storm. Although both are claimed to process the streaming data in real time. But Spark processes it as micro-batches; wh...

微服务

可以想像一下,之前的传统应用系统,像是一个大办公室里面,有各个部门,销售部,采购部,财务部。办一件事情效率比较高。但是也有一些弊端,首先,各部门都在一个房间里。

kibana, view layer of elasticsearch

What’s Kibana kibana is an open source data visualization plugin for Elasticsearch. It provides visualization capabilities on top of the content indexed on...

kibana, view layer of elasticsearch

What’s Kibana kibana is an open source data visualization plugin for Elasticsearch. It provides visualization capabilities on top of the content indexed on...

iConnect

UI HTML5, AngularJS, BootStrap, REST API, JSON Backend Hadoop core (HDFS), Hive, HBase, MapReduce, Oozie, Pig, Solr

Data Structure

Binary Tree A binary tree is a tree in which no node can have more than two children. A property of a binary tree that is sometimes important is that th...

Something about authentication

It’s annoying to keep on repeating typing same login and password when you access multiple systems within office or for systems in external Internet. There a...

SQL

Differences between not in, not exists , and left join with null

Github page commands notes

404 error for customized domain (such as godday) 404 There is not a GitHub Pages site here. Go to github master branch for gitpages site, manually add CN...

RenMinBi International

RQFII RQFII stands for Renminbi Qualified Foreign Institutional Investor. RQFII was introduced in 2011 to allow qualified foreign institutional investors to ...

Load Balancing

Concepts LVS means Linux Virtual Server, which is one Linux built-in component.

Python

(‘—–Unexpected error:’, <type ‘exceptions.TypeError’>) datetime.datetime.now()

Microservices vs. SOA

Microservice Services are organized around capabilities, e.g., user interface front-end, recommendation, logistics, billing, etc. Services are small in ...

Java Class Loader

Codecache The maximum size of the code cache is set via the -XX:ReservedCodeCacheSize=N flag (where N is the default just mentioned for the particular com...

Back to Top ↑