Individual Rethinking: Updating Our Views

Starts by talking about individual rethinking, The author listed four modes of thinking:

• Preacher: We’re convinced we’re right
• Prosecutor: We’re trying to prove someone else wrong
• Politician: We’re trying to win the approval of our audience
• Scientist: You favor humility over pride and curiosity over conviction. You look for reasons why you might be wrong, not just reasons why you must be right.

It looks obvious that the scientist thinking mode is the most “mature” way of thinking, but I can easily come up with cases that I’ve behaved as the other modes. It’s hard to maintain an open mind and research why we might be wrong instead of thinking about why we must be right. The author listed several stories about how rethinking has helped start-up revenues, or how intelligence became a curse for Blackberry’s failure in the competition with Apple.

“If knowledge is power, knowing what we don’t know is wisdom.”. I’m confident that I would stay in the rethinking cycle of Humility -> Doubt -> Curiosity -> Discovery -> Humility when learning new things, but it’s so easy to get into the overconfidence cycle when talking about some topics tech stack that (I believe) I’m fairly familiar with and know much more than average: Pride -> Conviction -> Confirmation & Desirability Biases -> Validation -> Pride. Especially on the validation part, when I got lucky in several discussions or even debates, it’s easy to tend to become conceited or even condescending. The curse of knowledge is we could close our minds to what we don’t know, and stand on the “summit of mount stupid”.

The ideal position to be both high in confidence and humility, or the “Confident Humility Zone”, which I believe I’m still seeking. To possess faith in my strengths while being aware of my weaknesses, I need to get an accurate picture of my knowledge and skills in the scientist mode. Although the author mentioned he somehow believes “we’re sometimes better off underestimating ourselves”, which I also agree with.

Interpersonal Rethinking: Opening Other People’s Minds

I’m not that passionate about winning debates and influencing other people, but it’s possible that when I think things are personal I lose passion/temper/whatever and ended up in at least one person in the debate becoming unhappy and nothing working out. One way to improve is by listening and finding common ground.

The book listed the debate between Harish and Debra debating, where the audience’s mind shifted several times when the debaters convinced people to rethink. The key points from Harish are: drawing attention to common ground and avoiding defend-attack spirals. Also, don’t step on people’s toes by throwing more reasons as preaching or prosecuting, as that would shut people’s minds as audience shielding against persuasions, and maybe even backfire. Instead, pose more questions, and open audiences’ minds that they might be wrong.

One thing to notice is “less is more”, when we put on several reasons on the table, the weakest one would be the easiest loophole to let people dismiss the entire case. “A weak argument generally dilutes a strong one”. This also applies when we’re writing a list of reasons for performance reviews :P

Collective Rethinking: Creating Communities of Lifelong Learners

It’s a basic human tendency to seek binary bias by simplifying a complex continuum into two categories, like good or bad, gun control or gun freedom, abortion or anti-abortion, Democrats or Republicans, Zero Covid or Living with Covid, or “those who divide the world into two kinds of people, and those who don’t”. It’s important to resist the impulse to simplify things.

The author also talked about the so-called life plans, by not setting boundaries by making plans. We should be mindful of the “tunnel vision” of plans that prevent us from seeing better possibilities.

Collective rethinking is also about changing organizational cultures, for example, a team that is agile in changing its mind collectively based on rethinking, although I wouldn’t want this agility to go too far either. One interesting point is “avoid best practice”, as best practice assumes the team has arrived at an optimal solution. I understand this belief will prevent effective rethinking, but since I’m a fan of “best practice” myself and believe it has more benefits, I would prefer stating this as “update best practice frequently”.

It’s also very normal for the plan to not work out, we should keep an open mind and spend time rethink about the plan on the way. To question your plan instead of executing it at any cost is the essence of rethinking, and this is something I’m also not very aware of. We always heard about determination but rarely about the direction that would lead to undesirable results.

Originally published at https://www.usegitflow.com.

Bill Gates explains his thoughts about a potential future crisis, clearly and thoroughly in the book <How to Avoid a Climate Disaster: The Solutions We Have and the Breakthroughs We Need>

The importance of “getting to zero”

We’ve heard the word “zero greenhouse gas commission” many times in the news or magazines because greenhouse gases absorb heat, trap it in the atmosphere, and cause global warming and rising temperature. We already know that if we don’t reduce emissions, the temperature would still grow between 4 to 8 degrees Celsius in this century. But apart from the direct effect of days becoming hotter and sea levels go up (which is already horrible), there are some efforts that I didn’t think about before reading this book.

The first trouble from a hotter climate is more extreme natural disasters like hurricanes and floods that destroy infrastructures and cause disasters. Hotter weather means droughts in the river or soil lands and more frequent and destructive wildfires in California and Australia in the year 2020. Rising sea levels because of melting polar ice and expanding seawater size as it’s warmer is that some cities are shrinking because of higher coastlines. Singapore is taking some steps to prepare itself for future issues caused by climate change.

When the weather is getting hotter, animals and plants would be affected. Some would suffer when some thrive, affecting essential businesses like farming significantly. With seawater getting warmer, even only 2 degrees, some seafood would be wiped out.

And these effects are not working individually but on top of the others. According to Bill, climate change can be just as deadly as COVID-19 by mid-century and five times as fatal by 2100. Economic damage caused by climate change would be equally enormous.

To answer the question “why should we (as a country) deal with this issue?” the most persuasive answer is that countries that build great zero-carbon industries will be leading the global economy in the coming decades. Big energy breakthroughs would be significant and welcomed by the world.

Significant topics to consider about Climate Change

According to the data in the book, greenhouse gas is emitted by these five categories as a proportion of:

1. Making things (cement, steel, plastic): 31%
2. Electricity: 27%
3. Growing plants and animals: 19%
4. Traffic (planes, trucks, ships): 16%
5. Keeping warm and cool (heating, cooling, refrigeration): 7%

Although electricity only accounts for just a quarter here, I think clean energy is the most important topic and can help with the other categories, like how electric cars help reduce carbon emissions. In the book, Bill talked about how to help with “zero greenhouse gas commission” for each category in different chapters.

Electricity One interesting new name I learned is “power density,” about how much power we can get from a square meter’s land. It turns out we can generate fossil fuels 500–10000 Watts per square meter, and for Nuclear, the number is 500–1000, when for Solar, it is 5–20, and for Wind, we can only generate 1–2 Watts per square meter. The author uses the word “Green Premium” to describe the extra cost we would need for switching to a zero-carbon option, and we need to find a new energy source that we can widely deploy with low or no Green Premium.

Today, natural gas and coal make up two-thirds of our electricity source because fossil fuels are cheap-fun fact: oil is more affordable than a soft drink. Bill discussed several other options that are possible to replace fossil fuels. Apart from the too much land needed problem, the sun and the wind are intermittent sources affected by weather, storing excessive electricity in batteries is super expensive, and hard to reduce the cost. If we want to use renewables for electricity sources, much faster innovations and more breakthroughs are needed about deploying renewables and improving transmission. According to this NYTimes review, the progress about batteries, solar, and wind energy is more optimistic than Bill thinks.

Other options include nuclear power (fission and fusion), the only carbon-free and reliable energy source. France is already getting 70 percent of electricity from nuclear, while the US around 20 percent. The significant shortage is that it’s costly to build, and human error caused several nuclear accidents or disasters in history. In the book, Bill compared Nuclear power with Coal and Oil and said deaths caused per unit of Nuclear electricity are far less, and safety concerns shouldn’t block people from using it. Of course, the world needs to improve on Nuclear safety.

Materials Cement, concrete, and steel are the materials being used worldwide at a faster speed, and they generate much more greenhouse gases than plastics when plastics have the worst reputation for climate change recently. We manufacture enormous materials, resulting in copious amounts of greenhouse gases, nearly a third of the 51 billion tons per year. We need to get those emissions down to zero, but it’s not an option to stop making things. Instead, Bill discussed several ways to drive the premiums down when adopting the zero-emissions approach.

Farming As people get richer, they eat more calories, particularly more meat and dairy. The more meat we consume, the more plants we need to grow, as six calories of feed for every calorie of beef. When we need to produce more food, we need to reduce the emissions during producing the foods when farmlands are already being infected from climate change. Artificial plant-based meat is a popular alternative for real meat, and the author highly recommends this approach (as an investor in plant-based meat companies).

Planting trees has been viewed as a popular forest-related solution for climate change, as trees capture carbon dioxide from the atmosphere. However, it’s not as simple as I consider it before. A tree absorbs carbon dioxide in rather a low efficiency, and if the tree dies, it will release all the carbon dioxide it stored back into the atmosphere. If we eliminate a farm for a forest, that may lead to somewhere else trees being cut down, and the benefits are offset. The most effective tree strategy for climate change is to stop cutting down trees we already have.

Traffic 8.2 billion tons of carbon is being produced from transportation today. During Covid-19, travel and trade have been limited, but even this reduction is not enough for the zero-emission target by 2050. And stop people from moving is also not a valid option. Passager vehicles are the source of half transportation-related emissions. Electric vehicles are already trendy, and the Green Premium of EV is coming down. But the main concern is that if the electricity is not coming from a clean resource, we’re not reducing the emissions, as it’s equal to moving gasoline around.

In the last three chapters, the author suggested the specific steps we can do, from government policies and world leaders to companies and investors to every individual of us.

COVID-19 and Climate Change

Bill Gates warned us of a COVID-19-like pandemic — watch his TED Talk from 2015. Now he wrote this book to warn people about climate change. Still, he’s being optimistic, pragmatic and thinks the world can avoid a disaster, as countries are making real progress. The world becomes more committed after Covid to solve a global problem. In the next decade, Bill thinks that the world should focus on the technologies, policies, and market structures that will put us on the path to eliminating greenhouse gases by 2050.

Book review by the Guardian: How to Avoid a Climate Disaster by Bill Gates review — why science isn’t enough

Originally published at https://www.usegitflow.com.

My experience

2020 has been, no wonder, a strange and challenging year almost for most people. We are isolated from the world where nearly no good news is going on, working from home and away from the office, colleagues, and friends since March, getting used to facing people under masks.

Being bored of the daily routine of WFH, I found out that there have been more chunks of spare time to spend, and because of my long-lasting curiosity towards Japan and Japanese, in May, I decide to try learning Japanese and see how far I could go. The target I made for myself is passing the 2020.12 JLPT N3 exams (the July exam happened to be canceled).

My motivation to learn Japanese is relatively straightforward:

• It’s an influential language in the world, especially in Asia and Singapore.
• Learning a new language is always pretty cool, and it can equip me with a new angle on the world.
• It’s close to Chinese. Two languages are similar concerning lexical similarity, and I can save some effort reading Kanji (but not reading). Japanese culture is influential to almost everyone around me. I watched several Japanese dramas and movies, including several times of Legal High.
• If I have time, effort, and interest, why not?

After seven months of learning, I took the JLPT N3 test in December 2020 at the Japanese Cultural Society of Singapore. Seven months of part-time study is not sufficient to master the language, and I met some difficulties during the text. Luckily the result turned out well. I got an A in both Vocabulary and Grammar, and a 60/60 for reading.

Learning path

I want to introduce my reference books, textbooks, exam books, and how I used them. I hope it can help somebody to start their journey of learning Japanese.

For reference books, I only bought three books, and these are more than enough for me.

• Random House Japanese-English Dictionary
• A Dictionary of Japanese Grammar, buy the Basic and Intermediate if you’re aiming N3. It may seem a bit pricey, but worth every penny.

The only textbooks I used is the complete set of 『みんなの日本語初級』 including Textbook and several workbooks, as this link shows. As I’m studying part-time, I spent around 1–2 hours learning these textbooks every day.

My steps of using 『みんなの日本語初級』 are:

1. Read the words following recordings.
2. Memorize the words through Anki iOS and Mac apps. It is an excellent app for memorizing Japanese words. I strongly recommend using it. We can easily find the vocabulary set of みんなの日本語 in shared decks.
3. Listen to the main text and shadow it. By shadow, I mean doing dictation as much as possible. I used my iPad Pro Notability app to write the texts down after repeating them several times. Of course, there would be words I don’t understand and Kanji I can’t remember. It’s totally fine.
4. Compare with the main text and correct my dictation.
5. Reread the text following the audio for pronunciation.
6. Read the grammar part. There are plenty of great Youtube videos explaining grammars in みんなの日本語. I attached my link in the next section.
7. Look up the grammar I don’t understand in ‘A dictionary of Basic Japanese Grammar’ or search it online.
8. Finish all the exercises and workbooks. And then I’ll give myself some rewards after the hard work. No more practices are required as the workbooks contain reviewing sections already.

I think after finishing 『みんなの日本語初級』textbook, you can just pass JLPT N4 exams easily without anything else. However, I need to fill in the gap as I signed up for the N3 exams.

After I finish 『みんなの日本語初級』textbook, it’s already October, two months before my JLPT N3 exam. In these two months, I’m focusing on only one set of books, Nihongo So-Matome JLPT N3 Complete Set. By finishing one section within five books every day, the timeline just matches well, and the book helped a lot for me to fill in the gap between 『みんなの日本語初級』 and JLPT N3. Vocabulary, Grammar, and Listening are the most critical parts, in my opinion, as test preparation somehow requires specific techniques and experience. I definitely didn’t memorize everything down, but I think by completing Nihongo So-Matome JLPT N3 Complete Set, it’s enough for me to pass the N3 exams. Things turned out well.

Some useful online resources

1. Learn Japanese: A Ridiculously Detailed Guide — Tofugu
2. 出口日語 【改訂版】大家的日本語文法解說 for grammar explanation
3. Online Japanese N3 Course(All 10 lessons) I think the series by Attain Corp. on Udemy are all well-made. You can buy all courses if you prefer learning through videos. It would take no less effort for sure. I think it can be suitable supplemental materials for 『みんなの日本語初級』
4. Siri :) I changed my Siri language settings to Japanese and talk to it sometimes. It’s quite helpful to practice my Japanese communication, especially during the lockdown period.

Hope this post can help some friends as a reference to reach the N3 level. I’m continuing my self-learning journey this year, hope I can share some N3 -> N2 experience some time :)

Originally published at https://www.usegitflow.com.

What makes a pragmatic programmer?

1. Over the long term, your time investment will be repaid as you and your team become more efficient, write code that’s easier to maintain, and spend less time in meetings.
2. You rarely take things as given without first getting the facts. When colleagues say “because that’s the way it’s done,” or a vendor promises the solution to all your problems, you smell a challenge.
3. We who cut mere stones must always be envisioning cathedrals.
4. Every day, work to refine the skills you have and to add new tools to your repertoire.

1. A Pragmatic Philosophy && Software Entropy

1. When you find yourself saying, “I don’t know,” be sure to follow it up with “-but I’ll find out.” It’s a great way to admit what you don’t know, but then take responsibility like a pro.
2. Before you approach anyone to tell them why something can’t be done, is late, or is broken, stop and listen to yourself. Talk to the rubber duck on your monitor, or the cat.
3. Don’t leave “broken windows’’ (bad designs, wrong decisions, or poor code) unrepaired. Fix each one as soon as it is discovered. If there is insufficient time to fix it properly, then board it up.
4. It’s time to bring out the stones. Work out what you can reasonably ask for. Develop it well. Once you’ve got it, show people, and let them marvel. Then say “of course, it would be better if we added…’’ Pretend it’s not important. Sit back and wait for them to start asking you to add the functionality you originally wanted. People find it easier to join an ongoing success. Show them a glimpse of the future and you’ll get them to rally around.
5. If you give your users something to play with early, their feedback will often lead you to a better eventual solution.
6. Talking to other people will help build your personal network, and you may surprise yourself by finding solutions to other, unrelated problems along the way. And that old portfolio just keeps getting bigger.
7. The more different things you know, the more valuable you are.
8. Know what you want to say. Know your audience. Choose your moment. Choose a style. Make it look good. Involve your audience. Be a listener. Get back to people. Keep code and documentation together.
9. if you don’t listen to them, they won’t listen to you.
10. Treat English (or whatever your native tongue may be) as just another programming language. Write natural language as you would write code: honor the DRY principle, ETC, automation, and so on.
11. A good idea is an orphan without effective communication.

2. A Pragmatic Approach

1. In the modern world, it’s critical to test ideas and get feedback before you commit to them whole-heartedly.
2. We feel that the only way to develop software reliably, and to make our developments easier to understand and maintain, is to follow what we call the DRY principle: Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.
3. Don’t rely on the properties of things you can’t control.
4. Requirements, users, and hardware change faster than we can get the software developed.
5. The distinction is important enough to warrant repeating. Prototyping generates disposable code. Tracer code is lean but complete, and forms part of the skeleton of the final system. Think of prototyping as the reconnaissance and intelligence gathering that takes place before a single tracer bullet is fired.
6. Our suggestion is fairly simple: don’t spend more effort than you save. Writing a domain language adds some cost to your project, and you’ll need to be convinced that there are offsetting savings (potentially in the long term).
7. Use paper, not a file or a wiki: there’s something special about the act of writing compared to typing. Give it a month, and see if you’re getting any benefits.

3. Pragmatic Paranoia

1. But Pragmatic Programmers take this a step further. They don’t trust themselves, either. Knowing that no one writes perfect code, including themselves, Pragmatic Programmers build in defenses against their own mistakes.
2. The finish what you start tip tells us that, ideally, the routine that allocates a resource should also free it.
3. Much of the time, tomorrow looks a lot like today. But don’t count on it.
4. Let’s look at four strategies that help: Finite State Machines, The Observer Pattern, Publish/Subscribe, Reactive Programming and Streams
5. Let us suggest three techniques that mean you should never need to use inheritance again: Interfaces and protocols, Delegation, Mixins and traits
6. We still want configuration data kept external to the application, but rather than in a flat file or database, we’d like to see it stored behind a service API.

Originally published at https://www.usegitflow.com.

As I’m learning Rust language recently, LeetCode becomes a good place to write some small programs and to get familiar with Rust grammar and syntax. In the recent contests, I tried using Rust to solve some problems however it took a much longer time than I expected, to deal with the strict compiler. Pretty fun though, and I think it did help me getting hands dirty.

However, personally I won’t suggest using Rust in LeetCode contests or in real interviews as Python/Ruby would be a much better choice. Rust could be useful in some other aspects which I’ll check later. (safety, speed, and concurrency? + WebAssembly) 🦀️

1234. Replace the Substring for Balanced String

Keyword: Sliding window

Use a counter to keep track of the appearances outside of the sliding window, and try to narrow the window as small as possible.

Rust solution:

use std::cmp;
use std::collections::HashMap;

struct Solution {}

impl Solution {
    pub fn balanced_string(s: String) -> i32 {
        let mut counter: HashMap<char, i32> = HashMap::new();
        for c in ['Q', 'W', 'E', 'R'].iter() {
            counter.insert(*c, 0);
        }
        for c in s.chars() {
            let new_count = match counter.get(&c) {
                Some(&val) => val + 1,
                None => 1,
            };
            counter.insert(c, new_count);
        }
        let length = s.len() as i32;
        let mut result = length;
        let expected = length / 4;

        let (mut j, mut i) = (0_i32, 0_i32);
        while j < length {
            let char_j = s.chars().nth(j as usize).unwrap();
            counter.insert(char_j, counter.get(&char_j).unwrap() - 1);

            // sliding window
            while i < length
                && counter[&'Q'] <= expected
                && counter[&'W'] <= expected
                && counter[&'E'] <= expected
                && counter[&'R'] <= expected
                {
                    result = cmp::min(result, j - i + 1);

                    let char_i = s.chars().nth(i as usize).unwrap();
                    counter.insert(char_i, counter.get(&char_i).unwrap() + 1);
                    i += 1;
                }
            j += 1;
        }

        result
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test() {
        let s = "QWER".to_string();
        assert_eq!(Solution::balanced_string(s), 0);

        let s = "QQWE".to_string();
        assert_eq!(Solution::balanced_string(s), 1);
    }
}

Some places in the code may be not necessary:

1. Update a counter’s value for a character, I’m using: let char_j = s.chars().nth(j as usize).unwrap(); counter.insert(char_j, counter.get(&char_j).unwrap() - 1); which is actually the same as counter[c] += 1 in Python. It seems too long in Rust.
2. For the place while i < length && counter[&'Q'] <= expected && counter[&'W'] <= expected && counter[&'E'] <= expected && counter[&'R'] <= expected, it would be all([counter[x] <= expected for x in 'QWER']) in Python 😅

1235. Maximum Profit in Job Scheduling

Keyword: DP

Use [(ending time, maxprofit)] to keep track of possible best profit for each end time. For new job, use binary search to find the possible previous ending time for last job, and calculate whether the profit would be better than the current best(last element in DP record), if so append it to the end of DP record vector.

struct Solution{}

impl Solution {
    pub fn job_scheduling(start_time: Vec<i32>, end_time: Vec<i32>, profit: Vec<i32>) -> i32 {
        let mut jobs = Vec::new();
        let length = start_time.len();
        for i in 0..length {
            jobs.push((start_time[i], end_time[i], profit[i]))
        }
        jobs.sort_by_key(|t1| t1.1);
        println!("{:?}", jobs);

        let mut record = vec![(0, 0)];  // (ending, max_profit)
        for (s, e, p) in jobs {
            let last_job_index = match record.binary_search_by_key(&s, |&t| t.0) {
                Ok(i) => i,
                Err(i) => i-1,
            };
            println!("{}, {:?}, {}", s, record, last_job_index);
            if record[last_job_index].1 + p > record.last().unwrap().1 {
                record.push((e, record[last_job_index].1 + p))
            }
        }
        record.last().unwrap().1
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test1 () {
        let starts = vec![1,2,3,4,6];
        let ends = vec![3,5,10,6,9];
        let profit = vec![20,20,100,70,60];

        assert_eq!(Solution::job_scheduling(starts, ends, profit), 150);
    }
}

1223. Dice Roll Simulation

Keyword: Cache

To make it not TLE we use a cache to reduce time cost. However in Rust it happened to be the very first HashMap I used and cost me some time to deal with compiler…finally made it pass with this code below. The <'a> is explicit lifetime which could be implicit.

use std::collections::HashMap;

// struct Solution {}

type Cache<'a> = HashMap<String, i32>;

impl Solution {
    pub fn die_simulator(n: i32, roll_max: Vec<i32>) -> i32 {
        let mut cache: Cache = HashMap::new();

        fn helper<'a>(
            k: i32,
            number: i32,
            n: i32,
            roll_max: &Vec<i32>,
            cache: &mut Cache<'a>,
        ) -> i32 {
            if n == 0 {
                return 1;
            }
            let key_string = format!("{} {} {}", k, number, n);
            let ref key = key_string.to_string();
            match cache.get::<str>(&key) {
                Some(&number) => return number,
                _ => {}
            }
            let mut temp: i64 = 0;
            for i in 0..6 {
                if number != i {
                    temp += helper(1, i, n - 1, roll_max, cache) as i64;
                } else if k < roll_max[i as usize] {
                    temp += helper(k + 1, i, n - 1, roll_max, cache) as i64;
                }
            }
            let result = (temp % (10_i64.pow(9) + 7)) as i32;
            cache.insert(key_string, result);
            // println!("temp: {}, result: {}", temp % (9_i64.pow(10) + 7), result);
            result
        }

        helper(0, 0, n, &roll_max, &mut cache)
    }
}

1240. Tiling a Rectangle with the Fewest Squares

Keyword: DP

It’s an interesting DP problem, as it only cares about 1<=n,m<=13 cases. For larger ranges it would become very complicated, please check this link for more info.

Solution in Rust:

use std::cmp::min;

struct Solution {}

impl Solution {
    pub fn tiling_rectangle(n: i32, m: i32) -> i32 {
        let mut record = vec![vec![0; n as usize + 1]; m as usize + 1];
        record[0][0] = 1;

        //special case
        if (n == 11 && m == 13) || (n == 13 && m == 11) {
            return 6;
        }

        for i in 0..m as usize + 1 {
            for j in 0..n as usize + 1 {
                if i == 0 || j == 0 {
                    record[i][j] = 0;
                    continue;
                }
                if i == j {
                    record[i][j] = 1;
                    continue;
                }
                let mut temp = 13*13;
                for k in 1..=min(i, j) {
                    temp = min(temp,
                               min(1 + record[i-k][j] + record[k][j-k], 1 + record[i][j-k] + record[i-k][k])
                    );
                }
                record[i][j] = temp;
            }
        }
//        println!("{:?}", record);
        *record.last().unwrap().last().unwrap()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test() {
        assert_eq!(Solution::tiling_rectangle(2, 3), 3);
        assert_eq!(Solution::tiling_rectangle(5, 8), 5);
        assert_eq!(Solution::tiling_rectangle(11, 13), 6);
    }
}

Originally published at https://www.usegitflow.com.

1. Explore Github GraphQL API: https://youtu.be/fX7mxRCDgJI
2. Download Insomnia client: https://youtu.be/Y2a68Zacv84
3. Authenticate request: https://www.youtube.com/watch?v=QZCw5dcu5Yg
4. Useful features for editing: https://www.youtube.com/watch?v=FkbTV_Q1a9Q
5. How to share my workspace?: https://www.youtube.com/watch?v=86KkpFAYOkA

Use cases when we work with a GraphQL endpoint

• Send my first request to a new GraphQL endpoint
• Introspection query to fetch the schema
• Manage environment-related variables like the authentication token
• Manage a bunch of queries
• Save/Share requests with others

How to use Insomnia to manage my requests?

Please check the complete youtube videos for a demo!

Here we’re going to communicate with Github’s public GraphQL API. Basic steps would be:

1. Automatic fetch GraphQL Schema from the endpoint.
2. Authenticating the requests through a personal access token, set the token as an environment variable.
3. Construct your query with the auto-complete feature enabled. Use variables when needed.
4. Send and check your response, work on fixing errors.
5. Export your current workspace and send it to your teammates. (Or use ‘Share’ feature which requires a Insomnia Plus subscription. 💰)

References

• Insomnia Official document for GraphQL Queries
• Github public schema

Originally published at https://www.usegitflow.com.

Follow the right guideline with the right tools to save your effort, and deliver the impressive, blazing fast website effectively! For React.js engineers.

Nowadays there are many excellent React.js programmers but not all of them can quickly deliver a responsive, blazingly fast portfolio website in a weekend without using a proper toolkit.

It can be quite common that we want to quickly build a portfolio to showcase our awesome products, but we wouldn’t want to spend too much time on coding every detail of the entire website. What we need are just the right tools to do the job and avoid repeat work. Suppose you are a software engineer who is already familiar with React.js, now this article is exactly what you want to guide your work!

What we want to build

Let’s say we want to build a portfolio website to present some nice blog articles, or to showcase a list of side projects. We expect it to have the following features.

• mainly it presents a list of items, could be article or projects,
• the website contains several static pages, we want to optimize the performance, the website needs to be responsive and sometimes mobile-first,
• need to be able to optimize for search engines, or SEO,
• can have a direct embedding section to a social network like Twitter,
• it allows visitors to leave some comments, but we don’t want to maintain a user authentication flow.

Most importantly, suppose that we only have one engineer who can write great React.js, but we don’t want to spend too much effort on building the website. That’s when the great GatsbyJS can come in handy! We can literally build the website as easy as building a Lego house.

The complete framework/tools/libraries to use

• GatsbyJS, after you’ve become familiar with React, of course.
• Github to host your code.
• Host service like Github Pages or Netlify. If you don’t have your own server, you need a service to host the website. Both platforms are free for deploying with a sub-domain!
• A Gatsby starter project as a quick boilerplate for your own purpose. Usually, I would recommend these few boilerplates, but you can view the whole list here:
• 1. for ecommerce: https://www.gatsbyjs.org/starters/parmsang/gatsby-starter-ecommerce/
• 2. for blogging: https://www.gatsbyjs.org/starters/gatsbyjs/gatsby-starter-blog/ or https://www.gatsbyjs.org/starters/alxshelepenok/gatsby-starter-lumen/
• 3. for showcase: https://www.gatsbyjs.org/starters/contentful-userland/gatsby-contentful-starter/
• 4. if you want to customize as most as you can, just use the advanced starter template: https://www.gatsbyjs.org/starters/Vagr9K/gatsby-advanced-starter/
• A UI framework to save your time from basic styling and responsive layout, I would recommend Bulma to do the job, with several templates

And for the GatsbyJS project, we need many Gatsby plugins to enrich the feature list. But it’s really handy as most plugins can be very simple to use, when they just require some minor config changes. Most of the plugins can be found (and already configured) in the starter templates, I’ll give a list here for you to check if you missed anything you need.

• gatsby-plugin-offline, to enable drop-in support for making a Gatsby site work offline and more resistant to unstable network connections, using service worker.
• gatsby-plugin-react-helmet, provides drop-in support for server rendering data added with React Helmet.
• gatsby-plugin-sitemap, create a sitemap for your Gatsby site.
• gatsby-remark-images, processes images in markdown so they can be used in the production build.
• gatsby-transformer-remark, parses Markdown files into contents.
• gatsby-plugin-google-analyticsm, easily add Google Analytics to your Gatsby site.
• gatsby-remark-prismjs, adds syntax highlighting to code blocks in markdown files using PrismJS.
• gatsby-plugin-feed, create an RSS feed (or multiple feeds) for your Gatsby site.
• several data source plugins, many ways to provide data to your website who can function as a simple read-only DB.

Because GatsbyJS would generate static websites from React project, we can also use popular React components here to enhance the functionalities. For example:

• react-twitter-embed, to embed Twitter timeline/share button in your page
• disqus-react, to embed Disqus comments module in your webpage
• any popular 3rd party UI libraries, but please keep bundle size in mind

Guideline

Prerequisites

1. Familiar with React.js programming, if not it’s really time to learn Reactjs now!
2. You have taken an hour to read over GatsbyJS official tutorial. Trust me, you only need an hour to know what does the concepts of GatsbyJS mean, it’s a good official tutorial.

Now you should know about the concepts like Gatsby starters, plugins, GraphQL query, page slugs, and how to use Gatsby CLI.

Let the rock begins!

In this section, we’ll walk through a guideline of how to build a reliable website in high efficiency. So grab a coffee and let’s begin!

I list it as the first step because it’s always important to keep in mind what you want to showcase, and what does the meta-data combined of. To be more specific, if you want to build a blog system, the data you need is possibly combined of {title, subtitle, description, slug, content, author, datetime, tags, category}. And for a product showcase site, you may need {product name, category, sale price, original price, description, where it's produced, where it's imported, product license, etc.}. I think it's fair to say that you need to design the data structure before design the website. And then you'll find many ways to provide data to your GatsbyJS project, using plugins listed here. Please notice that because the 'public' files you build is static, so it can't act like a PHP page which refreshes every time showing different data when the supporting database updates. Here you can only get the new website for the data change after building the static files again. As a hint, you can use gatsby-transformer-remark to build a blog from several markdown files, or use gatsby-source-mongodb to pull data into Gatsby from MongoDB collections. Never restrict your thoughts, why not use Google sheets to provide data? Actually, that can satisfy most portfolio sites, as what you eventually want to do is to present a list of data in a website. Isn't it?

Generally speaking, consider how to design the UI components that could be repeatedly used on your website. For example for blogs, the reused components could be:

• each blog page component, presenting the article details
• blog item component for the blog list, containing minimal details like title, description, creation date, etc, and link to the article.
• a card component to present best blogs in your index page, also containing some information and a link

Thanks to React, you can easily implement and test the components in a separate Component class, even styling inside the class using inline styles or some better approach. Please take a look at the Thinking in React article if you're not very clear about what I mean, and remember to reuse components.

I’ve already listed some starter libraries of my recommendation in the last section, you can also check this link for complete choices. A hint: if you’re familiar with how GatsbyJS works, take the most basic template and do your cool stuff inside. Otherwise, please take the template as much feature-rich as possible to save your effort. Ideally, for a simple website, most layout/routing/data source configuration work has been done in the starter library of your choice.

After having a clear idea about how the reused components should be presented, we can then focus on how the skeleton layout should be arranged, and put the components properly. We may expect to have some pages for a different router, for example for blogs we expect at list two different pages, a blog list page and an article detail page. An example is when using official blog starter template, you need to implement your design at least in these three files.

Usually, a navigation bar/menu is the first step, then another page container for each page is sufficient for small websites. This is when Bulma framework can be very handy (of course Bootstrap can also do the job if you’re already familiar with it). Just import the bulma.css style in your main style file (I would recommend using less/scss preprocessor CSS language), and take the 'out-of-the-box' components as you need. Another helpful website you can make use of is the Bulma templates site, which contains several useful layout templates for many different kinds of websites. Of course, you can't directly copy & paste all the time, but it can really save you some effort.

Another thing about layout I’d like to introduce is the CSS flexbox layout. As responsive design is becoming more and more useful nowadays, flexbox can be a very efficient and easy-to-understand way to layout your things. It’s also very easy in flexbox to align and centering things. CSS flexbox is already supported in all major desktop/mobile browsers.

OK, with some hard work we should now have some nice pages in hand. Next step is to bring it together as a working website. We’re expecting to run the website locally through gatsby develop in Gatsby CLI.

If you’re following a boilerplate to start your work, mostly you won’t need to worry about routing for pages as they are already there. If you need to implement some custom pages, Gatsby core automatically turns React components in src/pages into a new router to serve the new file. You can check routing docs for more information.

Because we have only limited time, so I skipped an important element for common websites: forms. It can be a very common use case that a website needs the visitor to submit some information, but mostly using forms would require a user login step so that we can know which user submitted this information, and that can cost some effort. I’ll talk more about it in the next section, but if you don’t want to spend much effort on forms, just use Google forms, possibly in a iframe. I'm not advertising Google product, but you really don't need to spend much effort when we already have a reliable way to 'implement' forms for our usage.

The same thing works for social network and comments system, by relying on 3rd party libraries. We can easily use React embedding components to embed social network, like twitter-embed to embed Twitter timeline in your page, or use disqus-react to embed Disqus for comments. Of course, it would introduce some issues like introducing 3rd party dependencies and ‘not saving data in our own server’, but personally I think it’s sufficient for many use cases. I’ll also talk more about it in the next section.

SEO is another built-in feature for GatsbyJS projects, as it can help you add required metadata for SEO on each static page, and it’s server-side rendered so all your information is available to search engines or crawlers. Basically, you only need to add required information in config file to make SEO work. Please check this doc and this plugin for details.

If you have your own server, simply build your Gatsby project and serve the public/ folder using Nginx or whatever, and that's it!

Otherwise, all possible deploying and hosting choices are listed here. I would recommend Github Pages and Netlify, especially Netlify which I used in two projects already and doing well. Netlify can have free CI integration with Github private repos, which allows build and deploy automatically from master code changes.

Both Github Pages and Netlify platform are free and widely used & recommended, here’s a simple comparison between these two platforms.

Because I just have a weekend…

Congratulations about how much you already achieved through the guidelines! Only in a weekend, you have successfully built a website with blazing fast performance and responsive design, which performs well in all platforms. Your audience would be impressed.

If given more time and effort, absolutely we can do more! Here are some aspects that I think you can continually work on.

1. User authentication. Sometimes you need to create a site with gated content and access control, Gatsby has a document about client-only routes which can control which pages user can access after logging in. Personally I would recommend using 3rd party OAuth authentication which could save lots of effort, another approach is using some server-side control like Netlify’s identity feature.
2. Localization, or i18n. It can be easily done by using any React i18n components, but pay attention that i18n is always related to routers. You can use a gatsby plugin to do the job.
3. Forms. Previously I mentioned that you can use Google Forms to act the form role, that could be not feasible sometimes. If you host a server-side code to deal with forms, you can send requests from front end form components to your server, as any React project does. Netlify also has a built-in form handling to help you host server-side code without actually running a server.
4. Styling. In the last section, we can build the system with a basic skeleton containing some layout and components in a short time, but the complexity may be not enough. You can check showcase and see how other complex website works with GatsbyJS. From my point of view, the complexity is the same, we just need to spend more effort on better layout styling and design more components, that’s all. Nothing special.

Thanks for reading! If you have any questions or suggestion, please leave a note or twitter me anytime.

Originally published at https://www.usegitflow.com.

A guideline for effectively building a responsive & blazing fast website in a weekend, using… was originally published in Hackmamba on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hi,

This is a introduction to my very recent project ‘Mark Notarize’, which is a very simple notarization DApp based on Truffle (http://truffleframework.com/) framework.

It’s open sourced with github link: https://github.com/markselby9/mark-notarize, and you can visit it directly through: http://matri.tech/.

You can check a demo gif below:

With Mark-Notarize, you can create a document with content for notarization, and it contains two blockchain addresses. Only account with the contained address can sign the document. After both sides have signed the document, it would be considered as ‘finished’, and can never be changed again. All documents are preserved on the blockchain network, for now I’m using Rinkeby test network.

It’s open sourced, and you can visit it directly through: http://matri.tech/. However there are some pre-requirements to visit the website:

• Modern browser with Metamask installed. link: https://metamask.io/
• After switching to Rinkeby network, you’ll need an account with some ether balance in it. Two websites which can give you some ether: http://rinkeby-faucet.com/, https://faucet.rinkeby.io/.

Mark Notarize is in a very early stage of development and will be updated later. Please check roadmap/plan: https://github.com/markselby9/mark-notarize/projects/1?add_cards_query=is%3Aopen. Again, it’s completely open source, please feel free to contribute/give issues if you have any interest. Thank you!

Project overview

We’re going to build an artificial neural network based, simple recommendation system web application. The application contains two pages, with first page showing books, and the second page showing movies. The user can select the books he or she is interested in in the first page, and when he clicks the next page button, we would actually predict what movies he would likely be interested in in the background. After the user finished choosing the movies he like, we would give the user a result showing what he chose and what we predicted about his choice. Some screenshots are shown below:

We’re using Vue.js and ElementUI ( a Vue.js UI framework) to build the application, and synaptic library to build the neural network.

What’s the advantages?

The advantages of our project can be concluded as:

• We moved the model training work to front-end instead of back-end, which reduced the server’s pressure and apportioned some computational power to many clients. That should be feasible thanks to the many neural network related Javascript library provided by npm community.
• We protected the user’s privacy. No user’s data has actually been transferred to server, they kept their data anonymous to server, when the server has updated it’s training model.

Simple introduction to Neural Network

First of all, the neural network we used here is a most fundamental ANN, and we also decided to use only the user’s selection to be input and output set. The images used in this section come from a nice introduction blog about neural network: https://ujjwalkarn.me/2016/08/09/quick-intro-neural-networks/.

The concepts involved in the project includes: Artificial Neural Network, neurons, layers and training (back-propagation).You can skip this part if you’re already familiar with these concepts. An Artificial Neural Network (ANN) is a computational model that is inspired by the way human’s brain work. It’s made up by neurons, which is a basic unit of neural network. Neurons receives inputs from other source, each input has a weight, which is assigned according to each input’s importance. And the neuron apply an activation function to the weighted sum of all inputs, then gives an output.

A layer is composed by several neurons, which looks like the image below. A neural network may or may not contain several hidden layers, each pair of neighboring layers have connections between them, which usually means the weight mentioned before.

But how can we design the network by correctly measuring these weights? We need to train it to let the neural network work properly. Suppose we have a table of data, which contains 1000 pair of inputs and corresponding outputs. We firstly gives all the weights by a random number between 0 and 1, and then iterate over all the data pairs. In each pair of input and output, we activate the neural network to give a calculated result, and compare it to the actual output. Then we would use back-propagation algorithm to retrain the network and adjust the weights. The weight updates of back-propagation can be done via stochastic gradient descent, which is a method to get optimal values for the weights.

In this article I only give a very brief introduction. For better reference, please check these links:

• https://ujjwalkarn.me/2016/08/09/quick-intro-neural-networks/
• https://en.wikipedia.org/wiki/Artificial_neural_network
• https://github.com/cazala/synaptic/wiki/Neural-Networks-101

Neural Network implementation in browser

Recently there have been some related works about implementing NN in browsers, like:

• Deeplearnjs, https://github.com/PAIR-code/deeplearnjs
• ConvnetJS, http://cs.stanford.edu/people/karpathy/convnetjs/
• synaptic.js, http://caza.la/synaptic/

We use synaptic.js here as it’s an architecture-free neural network library for both node.js and the browser, the documents can be checked through wiki in the github repository: https://github.com/cazala/synaptic/wiki/Architect. We plan to move all the neural network training and activation part in the browser, and the server (simple node.js server by express) only maintains a JSON file, which contains the network parameters. synaptic.js has a handy API to parse the neural network to JSON and parse JSON to a NN instance.

The application is built up by Vue.js and ElementUI. In the created lifecycle of the main app component, the application would fetch the model’s JSON file from server, and build a neural network instance based on the JSON file. Then it presents 20 cards containing movie information, and let the user select the items he/she is interested in. After the user finished selection and click next step, the network instance would call activate function, and give a predicted value about the books this user would possibly want (among the 20 options of books). Meanwhile, the application presents another 20 cards containing book information, and also let the user select. After click the submit button, the app would present the predicted book list and the actual book list to the user, and in the background use the new training data to back-propagate and retrain the model. After retraining, the new NN would be parsed as a JSON object and sent back to server.

Now let’s talk about the code. The server is a very simple express server with node’s file IO API.

app.post('/getNetwork', (req, res) => {
    if (req.body) {
        console.log(req.body);
        readJSONFromFile((network) => { // read local JSON file
            res.send({
                code: 200,
                network,
            });
        }, (err) => {
            console.log(err.toString());
        });
    }
});

app.post('/setNetwork', (req, res) => {
    if (req.body && req.body.networkJSON) {
        console.log(req.body);
        const { networkJSON } = req.body;
        saveJSONToFile(networkJSON, (err) => { // write to local JSON file
            if (err) {
                res.send({
                    code: 500,
                    err
                });
            } else {
                res.send({
                    code: 200,
                });
            }
        });
    } else {
        res.send({
            code: 406,
        })
    }
});

app.listen(3000, () => {
    console.log('server started');
});

And in the client, we would not dive into the DOM detail here in the article, we will just focus on the script part of the particular app.vue file.

created() {
            // fetch the train model from server
            this.content_data = this.shuffle(book_data);
            this.loading = true;
            axios.post('http://localhost:3000/getNetwork')
                .then((response) => {
                    console.log(response);
                    this.loading = false;
                    const networkJSON = response.data.network;
                    if (networkJSON && Object.keys(networkJSON).length > 0) {
                        this.$message('Received neural network from server.');
                        localNetworkInstance = Network.fromJSON(networkJSON);
                    } else {
                        this.$message('Created a new network instance.');
                        // create a new network instance
                        const inputLayer = new Layer(20);
                        const hiddenLayer = new Layer(20);
                        const outputLayer = new Layer(20);

                        inputLayer.project(hiddenLayer);
                        hiddenLayer.project(outputLayer);

                        localNetworkInstance = new Network({
                            input: inputLayer,
                            hidden: [hiddenLayer],
                            output: outputLayer
                        });
                    }
                })
                .catch(function (error) {
                    this.loading = false;
                    console.log(error);
                });
        },

Above is the created lifecycle hook in our application. It tries to fetch a JSON object from ‘getNetwork’ API, if it’s an available JSON configuration for network, it would create a local network instance through synaptic’s fromJSON method. Otherwise, it would create a new network instance and saves into ‘localNetworkInstance’ variable.

After the user clicks the ‘next page’ button from the first page, we call the activation function in the ‘onClick’ function, and save it as a predicted result in the Vue component’s data. Then after the user selects his/her interested films, a retrain function is called.

reTrainByThisUserData() {
    // retrain the model by this user's data
    if (localNetworkInstance) {
        localNetworkInstance.propagate(learningRate, this.trainingSet.output);   // propagate the network

        this.$message('Neural Network retrained!');

        const successFunc = () => {
            console.log('success');
            this.$message('Successfully sent the new Neural Network!');
        };
        const errorFunc = (error) => {
            console.log('error', error);
            this.$message(error);
        };

        this.loading = true;
        axios.post('http://localhost:3000/setNetwork', {
            networkJSON: localNetworkInstance.toJSON()
        })
            .then((response) => {
                this.loading = false;
                if (response.data && response.data.code === 200) {
                    successFunc();
                } else {
                    errorFunc(response.data);
                }
            })
            .catch(function (error) {
                errorFunc(error)
            });
    } else {
        this.loading = false;
        console.log('network is undefined!');
    }
}

The retrain process is a back-propagation process, by the current user’s selection as a pair input and output data. The user’s selection about movies would become the data for back-propagation. After back-propagation, the neural network’s weight would be adjusted, and the new data of neural network would be transferred to server and saved. Ideally, the new network should be stronger :).

You can do more …

As our reader may have already considered, we can do far more things than a simple recommendation system, using this strategy. Some possible roadmap for improving this project contains:

• More factors from the browser can be taken into account as input set, like time spent on each cards, user’s click event and scroll event, etc. These factors are accessible for front-end’s perspective.
• The neural network can have more complicated architecture, but meanwhile it can’t be trained overfitted.
• Build size should be taken into consideration for front-end project. Currently the build file size is around 1Mb, which is acceptable on PC but maybe too large for mobile sites. Optimizations should be taken if you want to use the project’s approach on mobile.

For the complete code of this project, please check the reference: https://github.com/markselby9/ml-in-browser/tree/feature/Recommendation_system_in_browser_demo.

Here in medium, I want to introduce a new state management library for Vue.js projects named Vuez. You can check the github repo at: https://github.com/markselby9/vuez.

In short, Vuez is a centralized monitoring ‘store’ which is accessible for all your Vue components after installing Vuez. From each component, you can access the store through this.$store.

The store concept in Vuez is very simple, imagine an excel table with three columns: ‘name’, ‘object’, ‘actions’. Whenever you are interested in monitoring an object or an event, you would like to start a new column in the table with a new name, with an object you plan to monitor. Then put everything you want to do when the object changed, as functions in the ‘actions’ column. Whenever you want to care about the ‘name’, you use store.observe(this_name) to observe it, if the object column's value has changed, all actions related to the name would be triggered.

It has only two set of APIs:

1. Observe/unobserve

store.observe(name, observing_object), takes two parameters: name is a string for the observer, and observing_object is an object to observe. If a name is firstly created as an observer’s name (firstly used in observe function), the object would be recorded. Then everytime whenever the observe function is called with the name, all actions with the name would be triggered if and only if the observing_object is changed.

store.unobserve(name) would cancel every action and observers related to the name.

2. Action

store.action(name, action_function), takes two parameters: name is a string for the observer, and action_function is the function to act when the object is changed during an 'observe'. The action_function here can have a parameter representing the current object value of the observing object.

With these simple APIs, Vuez can deal with many troublesome event handling such as data communication, monitoring data change, etc.

Let’s check a very simple example.

// Make sure to call Vue.use(Vuez) first before usage

const store = new Vuez.Store();
let changingObject = {
    number: 1
};
store.observe('changing', changingObject);
store.action('changing', (obj) => {
    console.log(obj.number);
});
observeObject.number = 2;
store.observe('changing', changingObject);  // trigger the action and console would show '2'

For somehow more detailed examples to use Vuez in your Vue.js projects, please check these links:

• Todo List
• Weather Application A weather application using Vuez and Vue2.x.

Currently Vuez is compatible with both Vue1.x and 2.x. As a newborn project, Vuez is currently under rapid development, and has a lot of space to improve. So please kindly give some suggestions, issues when you faced in usage, and PR if you’re interested. The more the better! :)

Thanks again for your time.