Data visualization is a crucial aspect of understanding complex data and making informed decisions. In the realm of web development, JavaScript libraries have become indispensable tools for creating interactive and visually appealing presentations of data. In this blog post, we will compare some of the most popular JavaScript data visualization frameworks, delving into their unique features, ease of use, and the scenarios in which they excel.

Why JavaScript: vs Python vs R

JavaScript libraries inherently excel in web environments, offering native support and high interactivity within web browsers. This is largely because JavaScript is one of the three pillars of modern web development, alongside HTML and CSS. HTML provides the structure, CSS adds styling, and JavaScript brings web pages to life by making them interactive and dynamic. This fundamental integration makes JavaScript indispensable for web development.

• Web Integration: Native and seamless. JavaScript’s ability to interact directly with the DOM allows for real-time content updates and manipulation without needing a page reload. This is a unique advantage that other languages cannot natively offer in a browser context.
• Interactivity: Unmatched. JavaScript’s direct support for browser-based interactions enables highly responsive and interactive user experiences. Whether it’s reacting to user inputs or updating visuals based on data changes, JavaScript stands out.
• Learning Curve: Variable. While JavaScript’s ecosystem offers libraries ranging from simple (Chart.js) to complex (D3.js), the language itself forms the backbone of web development, making it an essential skill for modern developers.

Python libraries, while powerful in data analysis and scientific computing, require additional tools and frameworks to integrate into web environments.

• Web Integration: Achievable with effort. Through frameworks like Flask or Django for general web development, and Dash for Plotly for data visualization, Python can power web applications but not without an additional setup layer.
• Interactivity: Context-dependent. High interactivity can be achieved in web applications using specific setups (e.g., Plotly with Dash), but it doesn’t match the native browser capabilities of JavaScript.
• Learning Curve: Moderately accessible. Python’s syntax is straightforward, making it a preferred language for beginners and experts in data science. However, integrating Python into web contexts adds complexity.

R libraries offer robust solutions for statistical analysis and visualization but also require a bridge to translate its capabilities to the web.

• Web Integration: Facilitated through Shiny. R can create interactive web applications via Shiny, which allows for direct deployment of R code as web apps.
• Interactivity: High in specific contexts. With tools like Shiny and Plotly, R achieves high levels of web interactivity, though this is within the confines of the Shiny framework.
• Learning Curve: Variable. The learning curve is moderate for libraries like ggplot2 but steeper for developing Shiny applications, requiring a deeper understanding of both R and web app deployment.

JavaScript’s role as a fundamental element of web development is underscored by its native browser support, unmatched interactivity, and the extensive ecosystem that ranges in complexity. This makes JavaScript uniquely positioned to offer direct, seamless web integration, a critical advantage for creating interactive, dynamic web applications. Python and R, while powerful in their respective areas, necessitate additional frameworks and setups to achieve web integration and interactivity, illustrating JavaScript’s integral role in the digital landscape.

JavaScript Library Comparison

D3.js: The Powerhouse of Flexibility

• Experience: D3.js is a veteran in the field of data visualization, known for its flexibility and comprehensive feature set.
• Motivation: Developers turn to D3.js when they need complete control over the visuals and interaction of their data presentation.
  D3.js, which stands for Data-Driven Documents, is not just a library but a framework that allows you to bind arbitrary data to the Document Object Model (DOM), and then apply data-driven transformations to the document. It’s the most robust framework of the lot, suitable for building complex and custom visualizations from scratch.
• Pros:
  - Complete control over the final appearance.
  - Large community and plethora of examples.
• Cons:
  - Steep learning curve.
  - More verbose and complex code for simple visualizations.

Chart.js: Simplicity Meets Elegance

• Experience: Chart.js is geared towards beginners and those who prefer simplicity.
• Motivation: It’s chosen by developers who want to quickly create standard charts with minimal fuss.
  Chart.js is a beginner-friendly library that provides beautiful defaults for a variety of chart types. It’s perfect for those who want to produce simple yet elegant charts with ease.
• Pros:
  - Easy to learn and use.
  - Responsive and mobile-ready charts.
• Cons:
  - Limited to the chart types provided.
  - Less flexible for custom, complex visualizations.

Three.js: A Journey into 3D

• Experience: Three.js is for those interested in adding dimensional depth to their visualizations.
• Motivation: Developers interested in integrating 3D models or creating data visualizations that pop out of the 2D screen.
  Three.js is a cross-browser library/API used to create and display animated 3D computer graphics in a web browser using WebGL.
• Pros:
  - Enables 3D visualizations.
  - Large set of tools and controls for 3D graphics.
• Cons:
  - More complex due to the third dimension.
  - Can be overkill for simple data visualization needs.

Plotly.js: The Best of Interactivity and Ease

• Experience: Plotly.js strikes a balance between ease of use and the depth of features, supporting a wide array of chart types with a focus on interactivity.
• Motivation:Plotly.js is ideal for developers and data scientists who want to create highly interactive, publication-quality graphs and charts with minimal effort. It caters to those who need to communicate complex data stories in an engaging way, allowing for dynamic visualizations that can be easily shared and embedded across various platforms. Whether it’s for academic research, business intelligence, or simply to provide an immersive data exploration experience on a web page, Plotly.js empowers users to bring their data to life without delving deep into the intricacies of coding complex visualizations from scratch.
• Pros:
  - Rich interactivity and customization options.
  - Seamless web integration.
• Cons:
  - Heavier for straightforward tasks.
  - Some learning required to exploit full capabilities.

Highcharts: Rich Features Out of the Box

• Experience: Highcharts is favoured by those who need enterprise-level data visualizations.
• Motivation: It’s perfect for developers who need a reliable, feature-rich library for professional projects.
  Highcharts is a charting library that makes it easy to add interactive charts to web applications. It is a commercial library with a variety of chart types and detailed documentation.
• Pros:
  - Wide range of chart types with interactivity.
  - Commercial support available.
• Cons:
  - License required for commercial use.
  - Heavier than some other libraries for simple projects.

Conclusion

The choice of a data visualization library is influenced by the project context, the desired level of web integration, and the development team’s familiarity with the technology. JavaScript libraries, especially Plotly.js, are inherently suited for web-based projects due to their ease of integration and native browser support. For data-intensive analysis leading to visualization, Python and R libraries remain strong contenders, bridging the gap to the web with tools like Dash and Shiny. Ultimately, selecting the right tool hinges on balancing project requirements, development efficiency, and the desired interactivity level of the final visualizations.

Credits:

Image Description: Intersection of 2D and 3D Data Visualization in Web Development
Source: Image generated by OpenAI’s DALL-E
Creation Date: April 5, 2024

A dog we met at Shoppers.

My two cats – Study Lord and Salted Fish.

I think Study Lord is studying bug-catching skills.

by Yiwei

Abstract

Recently I have been working on tasks with performance optimization of React pages, and I found some useful React-only tips, regardless of extra libraries (sorry, Redux/Recoil, not this time). One of the scenarios is some state or prop changes are causing repetitive re-rendering of the same component.

Here is Part 1, talking about some old stuff you may have heard somewhere else. If you feel something incorrect, please feel free to reach out to me.

Three Tips

1. Check states/props of unknown types in shouldComponentUpdate /hooks carefully.

It is recommended to pick a 3rd-party JavaScript package for object comparisons, especially when you need to compare prevState / prevPropswith state / props .

Many people prefer vanilla JavaScript methods, simply because they are faster. At least, cliché but true, don’t use === or == to compare states or props, even if you are CONFIDENT that the current data types of states/props used in this component are primitive enough. Next time, when someone in your team adds a new complex state value, the component would behave unlike what you expected.

• Big No:

shouldComponentUpdate(nextProps, nextState) {
#.... some props checks
    for (let key of Object.keys(this.state)) {
        if (nextState[key] !== this.state[key]) return true
    }
#.... some other checks
    return false
}

• Maybe Yes:

Here you can replace Object.keys(this.state) with a custom key set /array you designated like the keysToBeChecked below:

const keysToBeChecked = ['localAudioLv','localVideoLv' ,'RemoteVideoLv' ]

import { isEqual } from ‘lodash’

shouldComponentUpdate(nextProps, nextState) {
#.... some props checks

# here you can replace the Objects.keys(this.state) with the array `keysToBeChecked`
    for (let key of Object.keys(this.state)) {
        if (!isEqual(nextState[key], this.state[key])) return true
    }
#.... some other checks
    return false
}

If you don’t like Lodash.jsuse other packages like Underscore.js, Immutable.js.

Note: Since Lodash.js is derived from Underscore.js , in general, it’s a better option if you need more than a comparison. However, React officially to recommend Immutable.js.

2. Be aware of the React lifecycles, and setState when necessary

Technically re-setState the same value in states, won’t trigger the native (non-virtual) DOM updates (if I’m wrong, please correct me), but…

The default behavior is to re-render on every state change…

https://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/

Besides, many states may be passed to the children as their props, which would be a problem. That leads to unnecessary re-rendering of child components as well.

• Perhaps Better:

import { isEqual } from ‘lodash’ 
#... your Class methods. 

!isEqual(userAudioMap, this.state.userAudioMap) && this.setState({ userAudioMap })

#... your render() etc.

or

import { isEqual } from ‘lodash’ 
// better readability
if(!isEqual(userAudioMap, this.state.userAudioMap)){
 this.setState({ userAudioMap }) 
}

3. React.PureComponent is awesome, but use it carefully.

React.PureComponent’s shouldComponetUpdateonly shallowly compares the objects.

Only extend PureComponent when you expect to have simple props and state, Or consider using immutable.js (yes, again) objects to facilitate fast comparisons of nested data.

Pros:

• Developers don’t have to use shouldComponetUpdateexplicitly for performance improvement.

Cons:

• Due to shallowEqual , PureComponent won’t compare values for deeper differences, so the page may not be updated when needed.
• Need to make sure the states are primitive types or “simple” enough.

Next Chapter:

I will be writing something about dev tools to diagonalize performance problems.

Reference:

• PureComponent: https://reactjs.org/docs/react-api.html#reactpurecomponent
• Official Tips: https://reactjs.org/docs/optimizing-performance.html
• ShouldComponentUpdate: https://reactjs.org/docs/react-component.html#shouldcomponentupdate

Originally published at https://wilddunk.com on November 20, 2020.

Abstract

In 1997, the game between Deep Blue and Kasparov brought artificial intelligence (A.I.) into the public eye; 20 years later, AlphaGo’s overwhelming victory over Lee Sedol once again made A.I. a hot topic. Though both defeated the board game world champions, the most crucial difference between the two generations of A.I. is that Deep Blue is still a chess-specific A.I. based on brute force. At the same time, without any specific domain knowledge, AlphaGo can evolve based on machine learning. This difference determines that Deep Blue is just a symbolic milestone, while AlphaGo is more practical for real-life implementation. Thus, the new generation A.I. like AlphaGo may affect the board game and game players more deeply.

Keywords: artificial intelligence, board game, the algorithm

1. Contemporary A.I. and board games

1. A.I. development

Artificial intelligence, most known as A.I., dates from the summer of 1956 on the leafy campus of Dartmouth College (Vella, 2017), where artificial intelligence was essentially described as machines that can simulate human’s learning or other features of intelligence. Now A.I. has been one of the hottest research fields in science and engineering, which also truly affects each person’s life from communication, transportation, shopping, entertainment to basic living.

In decades of years, A.I. has developed so fast that Russell and Norvig (2010) point out that “the creation of human-level intelligence and beyond,” once accomplished by a human, “would change the lives of a majority of humankind” (p. 1051). Russell and Norvig (2010) further emphasize the ethical consequence that those super-machines at a certain level might “threaten human autonomy, freedom, and even survival” (p. 1051).

There has been live evidence of this statement right now: alpha Go developed by Google DeepMind group. With deep learning ability, this A.I. has made the threat into reality and shocked the whole world by defeating dozens of top human Go players with straight landslide wins (Going places; artificial intelligence, 2017).

2. Board games and A.I.

So far, five board games have been officially defined as mind sports by the 1st World Mind Sports Games: bridge, chess, draughts, Go and xiangqi (Chinese chess) (World Bridge Games Makes an Impressive Debut, 2008). Unlike A.I., board games have been fruits of human wisdom for thousands of years, but now these mind sports, especially chess and Go, may have become the top two board games affected by A.I.’s development heavily. For example, Kasparov and Greengard (2017) believe that after thousands of years of human dominance, the game is over now, and machines will be better than humans at chess forever.

After the narrow 1-match win made by Deep Blue on chess 20 years ago, A.I. has made defeating human players not challenging, with a 3–0 clean win to Ke (Going places; artificial intelligence, 2017). A.I. is progressing so fast that humans cannot practice continuously; likewise, 24 hours every day without rest (Atkinson, 2017). Another reason is the hardware development provides more vital computation ability than ever. Correspondingly, the computation strategy made significant progress from the hardware- heavy brute force to the software-heavy machine learning algorithm, which also optimized the outcome’s accuracy.

3. Methodology

After the algorithm comparison and research synthesis on the different implementations between Deep Blue and Alpha Go, including hardware dependencies and searching strategy, the insight may indicate a brighter future for human players and board game A.I.

It might be true that A.I. from now on would suppress the human players of board games, but analysis and evidence are supporting more proof that at least in the short term, human players may take full advantage of the development of the board game A.I.

2. Algorithm: Deep Blue vs Alpha Go

1. Deep Blue’s Algorithm

On the whole, Deep Blue is a set of hardware dedicated to chess, and most of the logic is implemented with circuits in the form of “Chess Chips.” There is a smaller amount of software responsible for scheduling and some high-level functions on the chess chip.

The core of the Deep Blue algorithm is based on brute force exhaustion:

• Generate all possible moves.
• Perform a search as deep-first as possible.
• Continuously evaluate the situation to try to find the best move.

The Deep Blue chess chip contains three main components: the Move Generator, the Evaluation Function, and the Search Controller. Each component’s design serves the goal of “optimizing search speed” (Campbell et al., 2002).

The move module is responsible for generating possible moves. The chess move module’s core is an 8*8 combinational logic circuit array, representing 64 grids of the chessboard. The chess move rules are embedded in the array in the form of hardware circuits so that the chess move module can give legal moves. There are additional logic circuits outside the core for detecting and generating special moves (such as “translocation of king cars”) (Campbell et al., 2002).

The evaluation module is the most critical part of the entire chip, occupying 2/3 of the chip area, more than half of the logic transistors and more than 80% of the memory transistors. The evaluation module is divided into three parts: the “position evaluation,” the “endgame evaluation,” and the “slow evaluation” (Campbell et al., 2002).

“Piece evaluation” scores the current positions of all pieces on the board. The scores of different pieces at different positions are pre-calculated by the software and written into the hardware. “Endgame evaluation” has also pre-stored a series of valuation rules specifically for endgames, such as the rule of “King centralization bonus.” The endgame evaluation sub-module also tracks all pawns’ positions in the form of an 8*8 combinational logic circuit array and calculates whether the pawn has crossed the opponent’s king and whether it can rush to the opponent’s bottom line to advance. Since the logic is embedded in the hardware, both the evaluation of the chess piece’s position and the evaluation of the endgame only requires one clock cycle to complete the calculation. (Campbell et al., 2002).

The search controller implements a minimum-window alpha-beta search algorithm, also known as the alpha-beta pruning algorithm, which can quickly reduce the search’s size (Campbell et al., 2002).

Deep Blue’s software patch is also specially designed to work with hardware. The software part is responsible for scheduling a search of up to 32 chess chips in parallel and is responsible for software evaluation of a large-scale planning situation. Deep Blue’s software is also connected to the endgame database of “only five pieces left.” Once an endgame with only five pieces left will directly search for the best move from this database. (Campbell et al., 2002).

2. AlphaGo’s Algorithm

AlphaGo is a pure software program that can run on general-purpose hardware. It is said that some of the programs use TensorFlow (Miller, 2016).

The core algorithm of AlphaGo is based on machine learning. In the first stage of training, AlphaGo only imitates chess players’ moves based on information unrelated to rules. By training a network with data from 30 million games, it can then predict human players’ next position with more than 50% accuracy. It is worth noting that at this stage, AlphaGo knows nothing about the rules of Go, just imitating it aimlessly. Nevertheless, since professional chess players will not violate the rules, it is equivalent to teaching AlphaGo to follow the rules of Go (Silver et al., 2016).

In the second stage of training, AlphaGo began to play chess with itself: the current strategy network would be playing with the networks in the past iterations, which will be used for self-reinforcing training. At this stage, the only rule of Go is introduced: reward the winning game. After this stage of training, AlphaGo surpassed all Go software. When played against Pachi, the most robust open-source Go software, AlphaGo, can achieve an 85% winning rate (Silver et al., 2016).

In the third stage of training, AlphaGo generates 30 million new training data samples from different Go compositions in different chess games during the self-playing game to train the composition evaluation function. The three-stage training strategy network is mixed into the Monte Carlo tree search algorithm to predict the potential situations of a chess game and evaluate them simultaneously (Silver et al., 2016).

In the entire algorithm, the concept of “winning” is the only input into the Go rule’s training process. Also, AlphaGo has no knowledge of Go rules and no advanced Go unique concepts. The first stage of training is entirely based on simple game data to achieve considerable predictive effects. This process has significant values in many areas that require the function of “prediction” or “forecast.”

3. An insight for board game and game A.I.

1. Technical metrics and computational mode

The Deep Blue II, which played against Kasparov in 1997 and won, is a 30-node R.S./ 6000 supercomputer, with 16 chess chips deployed on each node, a total of 480 chess chips concurrently (Campbell et al., 2002). Due to the embedding of a large number of dedicated chess logic and hardware implementation, Deep Blue does not have much reusability for IBM’s subsequent artificial intelligence (such as Watson) (Ferrucci et al., 2010).

The hardware used by AlphaGo is much more powerful. The distributed version of the game against Lee Sedol uses 1920 CPUs and 280 GPUs, and it is said that this version of AlphaGo has used Google’s self-made “tensor processing unit” (TPU) (Miller, 2016). Google claims that this chip is optimized explicitly for TensorFlow, and its computational efficiency is an order of magnitude higher than the GPU (Miller, 2016). Since it contains almost no domain-specific knowledge and runs based on general-purpose hardware, AlphaGo’s software is believed to be very simple. Most machine learning algorithms can be used to solve problems in other fields.

With powerful hardware and software improvement progress, some scientists and mathematicians believe the time of the A.I. explosion, or so-called technical singularity, is drawing near. For example, mathematics professor and science fiction author Vernor Vinge (1993) states that, within thirty years, humans will have the technology to create superhuman intelligence. Shortly after that, the human era will end. It is not a coincidence that many scientists and entrepreneurs also predict this threat. Bill Gates, Stephen Hawking and Elon Musk all think A.I. would be a vital concern or even a summoned demon (Peckham, 2017)

However, even if capable in a longer future, the most potential A.I. player is not created for replacements of players or competing for the championship against humans. DeepMind, the development group of AlphaGo, verifies that this machine will assist biological brains but not replace them in the end by helping people to find out new solutions to problems (Going places; artificial intelligence, 2017).

2. The changes in chess and Go games under A.I. development

In China, the training fees of senior Go players is one primary income source. However, when the A.I. online training shows up in recent years, more and more teenagers choose to be trained via the online platform.

Frias and Trivino (2016) discuss the possibility of robots playing sports with humans or themselves in the future. Using four questions named Frias-Trivino test, they do not think robots can be a real player due to the lack of the understanding of rules, the will to develop skills, and the joy while playing (Frias & Trivino, 2016).

3. The future of board game players with A.I.

Even for the top professional players, it looks tough to come through the sense of loss after being defeated by a strange and powerful enemy that is still growing and learning without rest and fear.

Garry Kasparov (2017) explains in his new book, he did not feel stressed, but he recalls that when he lost, he did hate the feeling. This defeat to A.I. on mind games not only represents the end of the man keeping winning against machines in the game but also begins a new era “for the rest of human history, as the timeline draws into infinity, machines will be better than humans at chess” (p.248). If the top players did feel desperate, will the others feel anything different?

Nevertheless, to a larger scale, the former world champion insists there is nothing to be afraid of, even when facing the future’s total loss. One reason is that the singularity when machines own “minds” like humans is still much far away. The other one is that with the combination of machines’ calculating power, humans’ creativity, and the other exclusive abilities, like purposes, Kasparov (2017) believes in a positive future for the technology.

To consider further, if the players combine the advantages of humans and machines, like adopting A.I. online training, the benefits of embracing A.I. will outweigh the potential dangers or frustrated feelings. Because machines do not feel tired, human players can easily find a super coach anywhere and anytime. More hopefully, DeepMind, the creator of AlphaGo, thinks the machines will end up as assistants, but not replacements (Going places; artificial intelligence, 2017).

Right now, we are more than glad to see after losing to AlphaGo, Mr. Ke studied the computer’s moves and found new ideas. He went on 22 straight wins against human opponents, an impressive feat even for the top one player in the world (Going places; artificial intelligence, 2017). This is proof, just as Kasparov (2017) points out, with the exclusive human creativity and the help of A.I., once players can make progress faster, we would be surprised by wisdom and uniqueness of our own, not the fear about what we made.

4. Board games with A.I. in the future

According to the analysis above, we can see that the new generation A.I. like AlphaGo, could improve the board game skills just like human players, even without the embedding of the game rules. This ability could be wildly implemented in other fields, like online tutoring and computerized forecast of professional leagues.

Also, there is no recent evidence showing that A.I. would be a threat to board game players. People would not recognize and admire A.I. equally as human players of board games since inhuman A.I. does not have the same structure and mental specialties as humans. Although professional players may lose to A.I., with the enlightenment of A.I., players would be aspired to work harder and learn new skills faster.

References

Atkinson, P. (2017). ‘The Robots are Coming!’: Perennial problems with technological progress. The Design Journal, 20(sup1), S4120-S4131.

Campbell, M., Hoane Jr., a. J., & Hsu, F. (2002). Deep Blue. Artificial Intelligence, 134(1–2), 57- 83.

Ferrucci, D., Brown, E., Chu-Carroll, J., Fan, J., Gondek, D., Kalyanpur, A. a., … Welty, C. (2010). Building Watson: An Overview of the DeepQA Project. A.I. Magazine, 31(3), 59–79. Frias, F. J. (2016). The defining components of the cyborg: cyborg athletes, fictional or real? Sport, Ethics and philoSophy, 10(1), 97–111.

Frias, F. J., & Trivino, J. L. (2016). Will robots ever play sports? Sports, Ethics and Philosophy, 67–82.

Going places; artificial intelligence. (2017, 10). The Economist, 425(9063), 76.

Hsu, F., Campbell, M., & Hoane, J. (1995). Deep Blue system overview. In ICS ’95: Proceedings of the 9th international conference on Supercomputing (pp. 240–244).

Kasparov, G., & Greengard, M. (2017). Deep thinking: Where machine intelligence ends and human creativity begins. Public Affairs.

Miller, P. Google reveals the mysterious custom hardware that powers AlphaGo. (2016, May 19). Retrieved from The Verger: https://www.theverge.com/circuitbreaker/2016/5/19/11716818/ google-alphago-hardware-asic-chip-tensor-processor-unit-machine-learning

Peckham, M. (2017). Future-proofing. Time Artificial Intelligence: The Future of Humankind, p. 90.

Russell, S., & Norvig, P. (2010). Artificial Intelligence: A modern approach,3rd ed. Pearson Education, Inc.

Silver, D., Huang, A., Maddison, C. J., Guez, A., Sifre, L., van den Driessche, G., … Hassabis,

Vella, M. (2017). How A.I. is transforming our world. Time Artificial Intelligence: The Future of Humankind, p. 5.

Vinge, V. (1993, Dec 1). The Coming Technological Singularity: How to Survive in the Post- Human Era. NASA CP-10129. Cleveland.

World Bridge Games Makes an Impressive Debut. (2008, October). Retrieved from 1st World Mind Sports Games: http://db.worldbridge.org/Repository/tourn/Beijing.08/Beijing.htm

Originally published at https://wilddunk.com on August 24, 2020.