The Predicament of Traditional Presentation Design

Traditional presentation design tempts us with endless customization options, promising visually stunning slides. However, it often comes at the expense of productivity and content quality. Valuable hours spent on design could be better invested in refining your message, conducting research, or practicing your presentation.

Moreover, style-related distractions can draw your attention away from content creation. Your audience may become so captivated by slide transitions or color choices that they miss your presentation's core message.

Markdown and Insou: A Game-Changing Solution

Imagine a solution where you can write presentations just as you write documents, focusing solely on content, not style. The quality of a presentation should be determined by its content, not its styling. This is where Markdown and Insou come into play.

The Power of Markdown

1. Efficiency: Markdown streamlines formatting, allowing you to write naturally while automatically applying consistent styling.

2. Consistency: Markdown enforces a unified style throughout your presentation, eliminating the need for manual adjustments on each slide.

3. Content-Centric Approach: With Markdown, you can invest your energy in crafting a compelling narrative supported by data and visuals.

The Magic of Insou

1. Seamless Conversion: Insou effortlessly transforms your Markdown content into a visually appealing PowerPoint presentation, saving you time and ensuring a polished final product.

2. Focus on Substance: With styling handled by Insou, you can dedicate your full attention to developing content that engages and informs your audience.

By embracing Markdown and Insou for presentations, you can shift your focus from the distractions of style to the essence of your message. Your presentations will become more effective, efficient, and engaging, allowing you to make the most of your valuable time.

In conclusion, the challenge of spending excessive time on styling and its adverse impact on content creation is a universal struggle. Markdown and Insou offer a transformative solution by promoting content-centric presentation creation. It's a game-changing approach that allows you to reclaim your time, captivate your audience, and deliver more impactful presentations.

Embrace the future of presentation creation with Markdown and Insou, where content is king, and style is a breeze.

Dreams, those shimmering stars in our imagination, guide us towards uncharted territories. They fuel our passion, urging us to push boundaries and overcome challenges. With each step, we inch closer to turning dreams into reality, etching our names in the annals of history.

But the journey is not without its share of obstacles. The pursuit of greatness demands unwavering commitment. It's a roller-coaster of emotions, ranging from triumph to setback. Yet, these highs and lows are the brushstrokes that paint the portrait of a true achiever. The ability to weather storms and emerge stronger is what sets apart the ordinary from the extraordinary.

The smiley face of determination is a universal symbol. It's a reflection of the spirit that propels dreamers forward. Just like a smile can brighten the darkest of days, a resolute mindset can turn challenges into stepping stones. 💪

Remember, every great accomplishment began as an audacious dream. Think of the Wright brothers, who dared to dream of flying, or Martin Luther King Jr., who envisioned a world free from discrimination. These icons embraced their dreams with open arms, nurturing them with unwavering faith until they became reality.

So, let your dreams be the wind beneath your wings. Embrace challenges, wear setbacks as badges of honor, and always keep that determined smile on your face. For it's through the pursuit of dreams that humanity continues to achieve greatness and leave an indelible mark on the canvas of history. ✨🌟

Here are some tips to avoid early-stage optimization and maximize your startup's success:

Build Your Dashboard Early 📊

It's important to know what's going on in your business. 🕵️‍♀️ By building a dashboard early on, you can track your key performance indicators and make informed decisions based on data. 📈

AB Testing is a Trap 🕳️

Don't waste time on excessive AB testing in the early stages. 🙅‍♂️ It's easy to get caught up in perfecting every little detail, but remember: the goal is to move fast and iterate quickly. 🚀 Focus on the big picture and address major issues as they arise. 🎯

Remember, it's okay to let your startup be a little rough around the edges. Only fix what's broken, and don't waste time on early-stage optimization. 🛠️👌

It is recommended to choose a simple task to be completed first that meets the following three characteristics:

• Not too difficult but easy to complete.

• Can quickly generate the first positive motivation.

• Can pave the way for the rest of the day's work.

Take your time to carefully select your first task and give the whole process a sense of ritual. When you arrive at the office in the morning, drink a glass of water and start your day's work.

First, check your To-Do List, select your "starting item" carefully, and complete it within 10 minutes to create a positive feedback loop that uplifts your mood. Then confidently tackle more complex tasks.

Imagine starting your day in a state of confusion and feeling unable to tackle complex tasks. This rhythm can make you more efficient and relaxed.

This way, you can create a positive mindset before starting your day, making it easier to focus, handle work pressure, and achieve job satisfaction and a sense of accomplishment. Remember that the first task of the day may not be your most important task, but it is the key to quickly getting into work mode and building confidence.

In addition, you can consider doing some preparatory work before your first task, such as drinking coffee, doing some stretching exercises, or reading a few interesting articles. These simple actions can help you get into work mode more quickly and improve your attention and focus.

However, choosing a "one-and-done" task is not the best option. Although you may get positive motivation, it's possible that you'll fall into a relaxed mood and choose to take another break, wasting valuable time. Therefore, it's important to carefully choose this task and make sure it is related to other tasks of the day.

Finally, don't forget to set specific goals for yourself every day and review and summarize your work after completing each task. This can help you better understand your work habits and efficiency and gradually improve your work performance.

In summary, although the first task of the day may seem insignificant, it can lay a solid foundation for your entire workday. Choose an easy-to-complete but related task to other tasks of the day.

In this article, we'll introduce some of the most commonly used Golang extensions for VSCode, along with examples of how to use them.

Go

The first and most essential extension for Golang development in VSCode is the official Go extension by Microsoft. This extension provides a range of features, including syntax highlighting, code completion, and debugging support.

To install this extension, go to the Extensions tab in VSCode and search for "Go". Once installed, you can start using the extension right away.

Go Test Explorer

The Go Test Explorer extension provides an interface for running and debugging Golang tests within VSCode. It displays test results in a hierarchical tree view, making it easy to navigate and view test results.

To install this extension, search for "Go Test Explorer" in the Extensions tab in VSCode. Once installed, you can start using the extension to run tests and view test results.

Go Auto Struct Tag

A Visual Studio Code extension for auto complete the go struct tag when typing. This project is the modified version of go-struct-tag by guyanyijiu

P.S: I modified this extension to suits my needs so I do not own most of the code,
You can visit the original version here go-struct-tag by guyanyijiu
I am open to new ideas, just create an issue or pull requests, Thank You!

Go Outliner

Go Outliner adds activity bar icon for code outline (Go projects only) to VS Code. It's also possible to extend main Explorer tab with sub-section by switching (goOutliner.extendExplorerTab) setting option to true.

GoDoc

The GoDoc extension provides a quick and easy way to access documentation for Golang packages and functions. It integrates with VSCode to provide inline documentation as you write code.

To install this extension, search for "GoDoc" in the Extensions tab in VSCode. Once installed, you can start using the extension to access Golang documentation.

These are just a few examples of the many Golang extensions available for VSCode. By using these extensions, you can significantly improve your Golang development workflow and produce higher quality code.

In this article, we will introduce the basics of the Go programming language.

Install Go

Before you start writing Go code, you need to install the Go programming language on your computer. You can download the installer for your operating system from the official website (https://golang.org/dl/). Just follow the instructions of the installer.

Write Hello World programs

Let's start with the Hello World program. Open your text editor and enter the following:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Save the file and name it hello.go. In the terminal window, change to the directory that contains the file and run the following command:

go run hello.go

The output should be:

Hello, World!

Variables and data types

Variable is one of the most basic building blocks in Go programs. A variable is an identifier used to store a value. In Go, variables must be declared before they can be used. The syntax for declaring variables is as follows:

var variable_name data_type

Here are some common data types:

• Bool: Boolean, true or false

• String: string, such as "hello world"

• int: integer, such as 42

• Float64: floating-point number, such as 3.14

  The following is a sample program that demonstrates how to declare and use variables:

package main

import "fmt"

func main() {
    var age int = 28
    var name string = "Alice"
    var isStudent bool = true
    var height float64 = 1.65

    fmt.Println(name, "is", age, "years old,", height, "meters tall, and is a student:", isStudent)
}

Alice is 28 years old, 1.65 meters tall, and is a student: true

Control flow

When writing a program, control flow statements allow us to execute different blocks of code according to specific conditions. Here are some commonly used control flow statements:

• If/else statement: allows us to execute different blocks of code based on a condition.

• for loop: allows us to execute the code block repeatedly until the specified condition is reached.

• switch statement: allows us to execute different blocks of code according to different conditions.

  The following is a sample program that demonstrates how to use the f / else statement and for loop:

package main

import "fmt"

func main() {
    age := 28

    if age >= 18 {
        fmt.Println("You are an adult")
    } else {
        fmt.Println("You are a child")
    }

    for i := 1; i <= 10; i++ {
        fmt.Println(i)
    }    
}

You are an adult
1
2
3
4
5
6
7
8
9
10

Function In Go

a function is a reusable block of code that takes some input parameters and returns a result. The following is a sample program that demonstrates how to declare and call a function:

package main

import "fmt"

func add(a int, b int) int {
    return a + b
}

func main() {
    sum := add(2, 3)
    fmt.Println(sum)
}

5

Structure

A structure is a custom data type that can store different types of data. The following is a sample program that demonstrates how to declare and use structures:

package main

import "fmt"

type Person struct {
    name string
    age  int
}

func main() {
    person := Person{name: "Alice", age: 28}
    fmt.Println(person.name, "is", person.age, "years old")
}

Alice is 28 years old

Package

packages are a way to organize related code. Every Go program must have a package called main, which is the entry point of the program. In addition, you can create your own packages and use them in other programs. The following is a sample program that demonstrates how to create and use packages:

Under the mathutils directory, create a file called add.go that contains the following:

package mathutils

func Add(a int, b int) int {
    return a + b
}

In 'main. In the go °file, import the ^ mathutils package and call the functions in it:

package main

import (
    "fmt"
    "mathutils"
)

func main() {
    sum := mathutils.Add(2, 3)
    fmt.Println(sum)
}

5

The above is a short introductory tutorial on the Go programming language. If you want to learn more about the Go programming language, check out the official Go documentation (https:l/golang). Orglclocl).

This is sad 😥

needs to be tried in other ways.

Jack was a marketing manager at a large corporation, and his job required him to juggle multiple projects simultaneously. He was always busy with meetings, emails, and phone calls, and his to-do list seemed to get longer and longer each day.

Jack had a habit of working long hours, often staying at the office until late at night just to try and get everything done. He felt like he was always playing catch-up, and he never had time to focus on the big picture.

The stress of his job started to take a toll on Jack's health. He was constantly tired and irritable, and he had trouble sleeping at night. He started to feel like he was stuck in a never-ending cycle of work, and he couldn't see a way out.

Jack knew that he needed to make a change, but he didn't know where to start. He had tried various productivity methods and tools, but none of them had helped him to manage his workload effectively. He felt like he was drowning in a sea of tasks, and he couldn't see a way to stay afloat.

That's when Jack stumbled upon Weedone. He was intrigued by its simple, week-based approach to task management, and he decided to give it a try.

To his surprise, it worked. Weedone was different. It helped him to prioritize his tasks and focus on what really mattered. He no longer felt overwhelmed by his to-do list, and he was able to achieve more with less effort and stress.

With the extra time that Weedone gave him, Jack started to focus on his personal life. He began going to the gym regularly and taking up hobbies that he had always wanted to try. He found himself with more free time than he had ever had before.

Then, one day, Jack's boss called him into his office. Jack was nervous, wondering if he had done something wrong. But his boss had nothing but good news for him.

"Jack, your productivity has increased significantly," his boss said. "We've decided to promote you to a higher position."

Jack was shocked. He had never expected to be promoted, and he knew that he couldn't have achieved this without the help of Weedone.

From that day forward, Jack continued to use Weedone to stay focused and productive. He recommended it to his colleagues, who soon saw the benefits for themselves.

With Weedone, Jack was able to break free from the cycle of stress and overwhelm. He started to see a way forward, and he felt like he had more control over his life. It was a turning point for him, and he knew that he would never go back to his old ways again.

Weedone helped Jack to see the big picture and prioritize his tasks based on what was really important. He was able to focus on the most critical projects and delegate some of the less important ones to his team. This gave him the breathing room he needed to start taking care of himself, both mentally and physically.

Jack was able to become the master of his time. He was no longer overwhelmed by his to-do list, and he was able to achieve more with less effort and stress. He realized that sometimes, doing less can actually lead to achieving more.

Counting elements:

• who

• counting object id

• counting object type

• counting increment

• create time

A single count is achieved by combining the above elements. Looking at it in the context of business, the counting needs are rough as follows:

• Number of views for an article

• Number of likes for a comment or answer

• Number of purchases for a product

• And so on.

enum ContentType {
    ContentType_UNKNOW              = 0;
    ContentType_ARTICLE             = 1;
    ContentType_QUORA               = 2;
    ContentType_TOPIC               = 3;
    ContentType_WINELIST            = 4;
    ContentType_WINECOMMENT         = 5;
    ContentType_TIMELINE            = 6;
}

enum CountingType {
    CountingType_UNKNOW             = 0;
    CountingType_PRAISE             = 1;
    CountingType_LIKE               = 2;
    CountingType_COMMENT            = 3;
    CountingType_VIEW               = 4;
    CountingType_READ               = 5;
    CountingType_FORWORD            = 6;
    CountingType_SHARE              = 7;
    CountingType_DOWN               = 8;
    CountingType_REPORT             = 9;
    CountingType_BUY                = 10;
    CountingType_SALE               = 11;
    CountingType_TSASTE             = 12;
    CountingType_FAVORITE           = 13;
}

In addition to these, there are also other needs, such as obtaining the recent count list, for example, the last 20 people who viewed an article.

Storage Structure

To meet the long-term requirements of the system, the storage structure needs to occupy as little space as possible and be highly efficient. Therefore, I have adopted a three-segment storage structure:

Segment 1: time_stamp & increment & counting_type

Segment 2: content_id & member_id

Segment 3: count

Three numbers constitute one counting operation, with each segment represented by an int64 data type. The theoretical size occupation is:

The theoretical storage size for this structure is such that 10GB of storage can hold up to 45 billion counting records, which is quite impressive.

2^8=256
2^16=65535
2^32=40 Billion
---
ONE:
+---+---------------------+------------------+--------------------+
|   |counting_type id(16) | increment id(1) | timestamp(ms)41 |
+---+---------------------+------------------+--------------------+

TWO:
+-----------------------------+
| content_id(32) | creater(32)|
+-----------------------------+

THREE:
+-----------------------------+
| total (32)                  | 
+-----------------------------+

query:
[ONE,TWO,THREE]: content_id00000000 >= content_id00000000 && content_id < (content_id+1)00000000

[[ONE,TWO,THREE],[ONE,TWO,THREE],[ONE,TWO,THREE]]

Data Structure

To add some fun to the code, I have chosen a team from a movie as the name for the data structure and assigned roles based on their character traits.

type (

    MetaItem struct {
        hOne   *HuBayi
        sTwo   *Shirley
        wThree WangKaiXuan
        hsw    []int64
        H      int64
        S      int64
        W      int64
    }

    // HuBayi: Team Core - The one in charge of every action: "Captain"
    HuBayi struct {
        time_stamp    int64
        increment     bool
        counting_type int64
    }

    // Shirley: Attentive and meticulous, responsible for intelligence work - "Spy" (or "Intelligence Officer") - records who the target is.
    Shirley struct {
        content_id int64
        member_id  int64
    }

    // WangKaiXuan: Greedy and responsible for managing assets and recording the total count - "Treasurer".
    WangKaiXuan int64
)

About the order of these three segments, there is a small trick that will be revealed in the querying section later.

Data Structure Construction:

func NewMetaItem(h *HuBayi, s *Shirley, w WangKaiXuan) *MetaItem {
    meta := &MetaItem{
        hOne:   h,
        sTwo:   s,
        wThree: w,
    }

    meta.Setup()
    return meta
}

func (this *MetaItem) Setup() {

    this.H = this.hOne.Value()
    this.S = this.sTwo.Value()
    this.W = int64(this.wThree)
}

As an example, let's use the character "Hu Bayi":

/*
+---+---------------------+------------------+--------------------+
|0 |counting_type id(16) | increment id(1)   |  timestamp(ms)41  |
+---+--------------------+-------------------+--------------------+
*/
func (this *HuBayi) Value() int64 {

    var incrementInt int64
    if this.increment {
        incrementInt = 1
    } else {
        incrementInt = 0
    }

    return this.counting_type<<CountingTypeShift |
        incrementInt<<IncrmentShift |
        (this.time_stamp - twepoch)

}

func (this *HuBayi) Parse(value int64) (int64, int64, int64) {

    time_stamp := (value & MaxTimestamp) + twepoch

    increment := (value >> IncrmentShift) & MaxIncrment

    counting_type := (value >> CountingTypeShift) & MaxCountingType

    return counting_type, increment, time_stamp
}

Scalability

• 16 bits are reserved for counting_type, which completely satisfies any future expansion requirements.

• To achieve maximum scalability, all timestamps do not start from 1997, but rather from a recent time, theoretically allowing the system to operate for another 20 years.

Querying

To query the total count, we only need to retrieve the last counting record, as Wang Kaixuan always records the final result after each counting operation. Here is an explanation of how to perform the query:

+---+---------------------+------------------+--------------------+
|   |counting_type id(16) | increment id(1)   |  timestamp(ms)41  |
+---+--------------------+-------------------+--------------------+

TWO:
+-----------------------------+
| content_id(32) | creater(32)|
+-----------------------------+

As mentioned earlier, we can convert the query operation into a comparison operation, which is much more efficient than string-matching operations.

By sorting the counting records by timestamp and keeping track of the latest count for each content_id and counting_type, we can quickly obtain the total count for each counting_type. Then, we can simply sum up all the latest counts to get the total count.

Since the fields in the CountingRecord struct are all integers, we can use comparison operators to compare them, which is much faster than string-matching operations.

content_id_select := content_id << model.ContentIdIdShift
content_id_select_max := (content_id + 1) << model.ContentIdIdShift

err = this.withDBContext(func(c *mgo.Collection) error {

    var err error
    query := bson.M{}

    query["s"] = bson.M{
        "$gte": content_id_select,
        "$lt":  content_id_select_max,
    }

    err = c.Find(query).Sort("-_id").One(&it)
    return err

}, this.dbSession,
    getDBName(content_type),
    getCollectionName(counting_type))

To find the desired record, we can use the content_id_select and content_id_select_max fields to define a range and then search for the maximum count within that range. Similarly, other query operations can be performed using this approach, such as finding the most recent likes list, whether a user has liked a certain content, the time of the like, and so on. Here is an example of how to find the maximum count within a range:

Sort the counting records by timestamp in descending order.

Iterate through the records and keep track of the latest count for each content_id and counting_type within the range defined by content_id_select and content_id_select_max.

Return the maximum count within the range.

This approach allows us to efficiently search for records within a specific range without the need to iterate through all the records, which would be much slower.

Database

That's correct. Since the system is designed using a general approach, it can be implemented on various databases including MongoDB, and the performance should not differ significantly.

Index

it's a good idea to create an index on the "h", "s", and "id" fields since they are used in the queries to identify specific records. By creating an index, the database can quickly locate the relevant records and avoid scanning through the entire collection. This can significantly improve the performance of the queries.

Performance

Real-time retrieval of billions of records in a single table

This system has low space consumption and high read/write performance, with a small amount of code. It has been running in production for many years.

End

The intermediate state of "omnipotence."

The intermediate status is a mysterious and versatile state that anyone can create. For example, a design may be in an evaluation state, where the invention is not yet complete, but it seems to be finished. So who is primarily responsible for this state, the designer or the reviewer? This is why evaluation states usually have two situations:

1. The evaluation period is very long, even exceeding the design time.

2. The evaluation becomes formalistic, and the problems leak into later processes, causing high costs to fix.

Anyone can create countless intermediate states, and they can usually make sense at first glance, but upon closer inspection, they are all wrong. But do we have the energy to deal with a massive number of intermediate states? A large amount of excellent creativity is used here; it is simply a breeding ground for creativity. Therefore, please block this path, cut off these "smart" ideas, and do something stupid instead.

Therefore, please get rid of intermediate states and make a clear definition of what is to be delivered, first by establishing the Definition of Done (DoD).

• The DoD of a specific feature, for example, this feature has been developed and is in a deployable state, verified by the product owner.

• The DoD of an iteration, for example, all planned features of this iteration have been completed.

• The DoD of a release, for example the entire software is in a releasable state, and the release plan has been defined.

Once we establish a clear DoD in our collaboration, we can even solidify it through processes to efficiently and effectively complete our work.

Delivery

This is the first issue to communicate because delivering stable software that meets business requirements is the fundamental responsibility of a technical person.

Most collaboration problems are caused by the need for a clear Definition of Done (DoD). Different parties have different understandings of what "Done" means, and they use various intermediate states to cope with the situation, which leads to inefficiency and wasted time in the end.

Function development completed

It means that the developer has gone through the requirements analysis, solution design, code implementation, and unit testing and has passed the acceptance test by the testing personnel, ensuring that the code is in a deployable state and the relevant documents have been completed.

Code writing completed

It means that the developer has written the functional code, the unit test code, and the integration test code, and the tests have passed. The code has also passed the code style check and the test coverage check.

Therefore, when referring to "function development completed" or "code writing completed" in subsequent communication, please refer to the above requirements. If you are unsure about what "Done" means in your work, please immediately confirm with relevant colleagues.

The above delivery information was taken from the department's culture document, which provides a clear and minimal definition of "Done." When a team member changes the status of their work, everyone in the team knows exactly what it means.

Remember:

There's only completed and not completed, and 99% of the time, there's no difference between the two.

If we can hire top talents, our business will develop better and faster; if our company develops better and quicker, we can hire top talents.

Build a great corporate culture like Google and provide the world's best products and services; use the best products and services to build a great corporate culture.

We want to have a membership model, but the benefits we can offer members are not enough at the moment; we need to prepare businesses that could provide potential membership benefits, but the membership model is still not on the agenda.

If we have more time, we can deliver better products; if we have already delivered better outcomes, we can get more time.

The team's average level is low, and we must be hands-on to ensure reliable quality delivery, but the team's growth rate is slow. If we are not hands-on, we cannot meet the quality requirements.

Unit testing can ensure quality, but it requires more time. The guru says unit testing can reduce project time and bring immense benefits.

We want to learn and improve ourselves, but our lives and work have taken up much time.

We want to do trendy and cool businesses, but that is a double-edged sword.

There are many problems in life and work, with no clear answer to whether to have the chicken or the egg first. It's a real problem.

But really, it doesn't matter which comes first. It's about what you want.

Startups want to do a good job on their business while building excellent mechanisms like Google.

If the business is a little better, they can hire better people. If the team is better, the company can take off.

They want to do a membership model like Netflix, but the benefits for members are too few for their current businesses.

If they had more time, they could deliver better products.

There are countless contradictions and deadlocks in work and life.

Being trendy and relaxed is a double-edged sword.

It doesn't matter whether you have the chicken or the egg first. Just take a small step forward and run it carefully. The first step is to assume that one of the two exists. Then it's simple:

• Know what to do (use what you have to do it)

• Identify the problem (lack of the other thing)

• Plan the path and execute y = f (x)

• Wait for the results

Take a small step, choose one, and don't hesitate or waver. Many people are not firm enough in their actions.

Math teachers teach us a standard method when solving problems: assume N, then M, so O. Assume X, then Y, so Z.

The Method of Assumption

Let's look at a math problem for elementary school students:

Example: The perimeter of a rectangle is 36 centimeters. If the length and width are increased by 3 centimeters each, how many square centimeters larger is the new rectangle compared to the original one?

Using the usual problem-solving method, we need to find the difference between the two areas, but we can't determine it based on the conditions given. If we assume that the length and width of the rectangle are 10 centimeters and 8 centimeters, respectively, and each is increased by 3 centimeters, that is (10+3) centimeters and (8+3) centimeters, we can calculate:

Original rectangle area: 10 × 8 = 80 (square centimeters)

New rectangle area: (10+3) × (8+3)

I remember getting stuck in a rut in school, always doubting whether those assumptions were even accurate. It made me fall behind and waste so much time before finally figuring out the answers.

But in the end, after checking with my classmates, we found that the solution was almost identical to what we had discussed earlier.

Although the question was simple, the lesson was profound: there are always more ways to solve a problem than obstacles, so keep looking until you find it.

Confidence isn't just about confidently talking about what you know; it's about having a positive attitude and a problem-solving approach to the unknown.

In the world of startups, there are problems, but most can be boiled down to one thing: the initial beautiful vision and numerous advantages can't be delivered. Promising too much can confuse people and make them feel like everything is possible, but nothing is good enough. This goes for investors and bosses and even more so for users. Keep the features simple and easy to understand. Simplicity is the right way to start.

Here's a breakdown of how to execute it:

• First, assume that you have the chicken or the egg and evaluate whether the risks are entirely unsolvable.

• Based on the assumptions, assign different parts and set growth vectors.

• Each part will make good progress.

• Risks and problems will converge, showing a decrease in entropy.

• Find all resources to solve the converged problems.

Good = f (Bad)

Let's start with layoffs.

Facing a layoff can be a daunting task for any team.

There are many issues to tackle, such as adjusting schedules, changing plans and goals, dealing with team morale, etc. It can be overwhelming when many team members experience this situation for the first time. As the department leader, you must remain level-headed and handle several areas of responsibility, including:

• Business progress adjustments

• Communicating with parallel departments about collaboration issues

• Plans Defining the scale and pace of layoffs Calming down team members

• Find out various unexpected hidden difficulties, and more With so many things to take care of

• the department head must first understand their responsibilities.

Turn "Bad" Things into "Good" Things

This is a regular thing. When business performance is poor, the company may need to reduce headcount. This type of thing happens all the time; it is just that it is the first time you have experienced it.

During this process, everyone will face their thoughts. It is essential to think forward and take the next step. The only thing that is not important is self-pitying in negative emotions.

Layoffs themselves are not brutal, and layoffs should not be the goal. The goal should be that every person becomes more robust after the layoff, the team becomes more muscular, and the business becomes more robust.

The basic principle is turning a "bad" thing into a "good" one.

The Dreaded 'x'

During this process, it was found that a considerable number of team members fell into negative emotions. This includes those who have to leave and those who have to stay.

Complaining, fear and negativity can all influence each other. Negative emotions are naturally highly contagious.

"Good things don't go out, but bad things spread for miles."

One of the most important reasons is that they are involved parties. We can think about this problem using a work-based approach.

We can define this situation as variable "x," and we need to turn this negative variable "x" into a positive variable "y" through the function:

y = f (x) ==> Good = f (Bad)

Then, we can analyze the factors that affect "x" and it will be easier to conclude with "y"

The company should maintain continuous delivery capability, and the progress and plan adjustments should be communicated promptly, accurately, and transparently to all stakeholders to ensure everyone is on the same page.

For everyone, learning how to face "x" with the right mindset is their most significant opportunity for growth.

Everyone will face countless difficulties and challenges in life and work, and learning how to face problems is the most difficult part. Many team members have grown in different ways through this process, such as:

• Improving their skills and competitiveness

• Ensuring that everything is business-oriented and ensuring business growth for everyone's safety. Actively dealing with problems rather than complaining.

In conclusion, this is an excellent way to handle most negative things individuals encounter.

Define each difficulty you face as "x," and then write the logic of "Good = f (Bad)."

This method can help turn negative things into positive ones.

Finally

"The basic principle is to turn a 'bad' thing into a 'good' thing. It is appropriate to turn a good thing into a good thing, foolish to turn a good thing into a bad thing, and mediocre to turn a bad thing into a bad thing.

A person's value lies in turning a bad thing into a good one, which is also the fundamental difference from others."

“Get things done with less effort - prioritize what matters with our app.”

“Make progress where it matters - simplify your to-do list with our app.”

“Focus on what truly counts - achieve more by doing less with our to-do app.”

Pretty good.

the tags in Bear APP are denoted by double hash symbols (##). However, we have made a change to the way tags are defined. And any content immediately followed by a single hash symbol (#) will be treated as a tag and will end directly with a space.

For the parser, still do some preliminary introduction, in fact, the steps are as follows:

Source Code -> Lexer -> Token -> Parser -> Abstract Syntax Tree

so, let's begin to build a parser with Rust

Token

In Go language, Token is generally defined as String, and like this

type TokenType string

const (
    TokenTypeILLEGAL = "ILLEGAL"
    TokenTypeEOF     = "EOF"
    Ident            = "Ident"
    TokenTypeCOMMENT  = "#"
    TokenTypeCOMMENT2 = ";"
    TokenTypeASSIGN   = "="
    TokenTypeLBRACKET = "["
    TokenTypeRBRACKET = "]"
    RETURN = "RETURN"
)

share a powerful feature of the Rust programming language - enumerations. The capability of Rust enumerations goes beyond what we previously understood. Not only can they have different data types, but they can also associate data.

This opens up new possibilities for defining objects such as tokens. In Rust, we can define a Token like this:

#[derive(PartialEq, Debug, Clone)]
pub enum Token {
    ILLEGAL,
    EOF,
    INDENT(Vec<char>),

    SHARP(char), // #
    Colon(char), // ,
    MINUS(char), // -
}

Lexer

The next thing to implement is the lexical analyzer.

use super::token;
pub struct Lexer {
    input: Vec<char>,         
    pub position: usize,      
    pub read_position: usize, 
    pub ch: char,             
}

impl Lexer {
    pub fn new(input: Vec<char>) -> Self {
        Self {
            input: input,
            position: 0,
            read_position: 0,
            ch: '0',
        }
    }
}

reading Tokens in Rust - using a finite state machine. This approach involves continuously reading the next character until the corresponding identifier is found. If the identifier is not found, the process continues until a match is found or until the end of the input is reached.

If you are interested, please refer to Finite-state machine-Wikipedia

pub fn read_char(&mut self) {
    if self.read_position >= self.input.len() {
        self.ch = '0';
    } else {
        self.ch = self.input[self.read_position];
    }
    self.position = self.read_position;
    self.read_position = self.read_position + 1;
}

fn peek_char(&mut self, offset: usize) -> char {
    let position = self.read_position + offset;

    if position >= self.input.len() {
        return '0';
    } else {
        return self.input[position];
    }
}

pub fn next_token(&mut self) -> token::Token {
    let tok: token::Token;
    self.skip_whitespace();

    match self.ch {
        '#' => {
            tok = token::Token::SHARP(self.ch);
        }
        '0' => {
            tok = token::Token::EOF;
        }
        _ => {
            let ident = self.read_statements();
            if ident.len() > 0 {
                tok = token::Token::INDENT(ident);
            } else {
                return token::Token::ILLEGAL;
            }
        }
    }

    self.read_char();
    tok
}

Our focus is on identifying the tags within the content, and as a result, we do not need to fully identify and optimize other content.

We will be running this example as a lexical analyzer, which is responsible for breaking down the input into Tokens.

In the previous implementation of our Go INI parser, we used a Parser to recognize the Tokens and turn them into an abstract syntax tree. However, for the purposes of this example, we will not be constructing an abstract syntax tree.

Parser

build a parser

pub struct Parser {
    pub lexer: Lexer,
    peek_token: Token,
    pub input: Vec<char>,
    tokens: Vec<Token>,  // 将token存入Vec即可
}

impl Parser {
    pub fn new(input: Vec<char>) -> Parser {
        let l = Lexer::new(input.clone());
        Parser {
            lexer: l,
            input,
        }
    }
}

pub fn parse_documment(&mut self) -> Result<Document, ParseError> {
    self.current_token = self.lexer.next_token();
    self.peek_token = self.lexer.next_token();

    self.tokens.push(self.current_token.clone());

    while self.current_token != Token::EOF {
        self.next_token();
        self.tokens.push(self.current_token.clone());
    }
    self.transform_to_document();
}

fn transform_to_document(&mut self) -> Result<Document, ParseError> {
    let mut document = Document {
        ..Default::default()
    };
    self.read_token();
    loop {
        let mut offset = 0;
        match &self.current_token {
            Token::SHARP(_) => {
                let peek_token = self.peek_token_next1();
                match peek_token {
                    Token::Statement(chs) => {
                        let mut tag = Tag::default();
                        tag.id = chs.into_iter().collect();
                        document.tags.push(tag);
                        offset = offset + 1;
                    }
                    _ => {}
                }
            }

            Token::Statement(ident) => {
                let state_ident: String = ident.into_iter().collect();
                if document.name == "" {
                    document.name = format!("{}", state_ident);
                } else {
                    document.name = format!("{} {}", document.name, state_ident);
                };
            }
            Token::EOF => {
                break;
            }
            _ => {
                return Err(ParseError);
            }
        }

        self.read_position = self.read_position + offset;
        self.position = self.read_position;
        self.read_token();
    }

    Ok(document)
}

Ok, testing it...

#[test]
fn test_parse_note() {
    let case = "#tag/tag1 this is a note hahaha. #tag1/tag22"
    let mut parser = Parser::new(case.chars().collect());
    let document = parser.parse_documment().unwrap();
    println!("{:?}", document);
}

Result:

Document { id: "", name: "this is a note hahaha.", craete_time: 0, tags: [Tag { id: "tag/tag1", parent: "", icon: "" }, Tag { id: "tag1/tag22", parent: "", icon: "" }] }

finished the task successfully.🏄‍♀️

1. Time management: By tackling important tasks first, you can ensure that you have enough time to complete them before moving on to other tasks that may not be as urgent.

2. Increased productivity: Focusing on the most important tasks first can help you achieve your goals more efficiently and effectively.

3. Stress reduction: Doing important tasks first can reduce stress and anxiety, as you will have a sense of accomplishment and be able to cross items off your to-do list.

4. Improved focus: Starting with important tasks helps you maintain focus and concentration, making it easier to complete the task at hand.

5. Better results: By focusing on the most important tasks, you are more likely to produce higher quality work and achieve better results.

6. Increased motivation: Completing important tasks can provide a sense of satisfaction and boost your motivation to keep working towards your goals.

7. Avoid procrastination: By doing important tasks first, you reduce the chance of procrastination and avoid the negative effects that come with it, such as increased stress and decreased productivity.

8. Better planning: Prioritizing important tasks helps you plan your day or week more effectively, ensuring that you are using your time and resources in the most efficient manner possible.

9. Improved time management: By doing important tasks first, you are more likely to finish your work within the given time frame, reducing the chances of having to stay late or work on weekends.

10. By prioritizing important tasks and doing them first, you can improve your productivity, focus, and overall success in both your personal and professional life.

Overall, prioritizing important tasks and doing them first can help you be more productive, reduce stress, and achieve your goals more efficiently.