/tmp/bucket

A place to dump my thoughts

0%

Posted on Edited on In 
1
UI/UX 設計師是一種諮商師。

#1

work

  • made thumbnail asset browser!
    • address web url display issue, how to click on it
    • Windows path issue happens multiple times…

#2

it was a rainy week…
but my mint seems being happy of it

#3

紫微斗數

#4

火毒 LV.75
多立百烈一隻應該 3000 EXP，為什麼實際打好像只有 2250？

Posted on Edited on In

2025-05-22

  • Nonviolent Communication
  • PMS
  • startup
  • Agile

Posted on Edited on In

#1

made 真正意義上的 maya plugin
learned

  • what is .mod
  • working format for a plugin (some interfaces/methods are required and is diff between api 1.0 and 2.0)
  • what is scripts/
  • userSetup doesn’t work at all (even security off)

#2

思考放長假的必要…
或許需要限制一週開發的進度，達到了就果斷休息。
開會，比認知中還要耗費精力，即使只是參與。

#3

目前日文線上課程

  • 優點：有框架、比較有方向
  • 缺點：做題時不立即有感->無反饋
    覺得聽日文podcast比較有趣，也比較聽得懂；但可能對考試沒有立即性幫助

which is more important?

  • 學習日文的心
  • 高效攻克測驗

#4

added Dubrovnik to to-go list

有沒有可能去這樣的地方然後還有錢賺？

#5

六月有機會去 LA 出差，想藉機去曠野


Photo by Victor Yuyang Luo on Unsplash

#6

火毒 LV 57

Posted on Edited on In

#1

  • communicated with outsource dev. prepared materials, docs, tried to make things easier and removed blockers.
  • i like how the outsource dev works, communicates and organizes things. very inspiring. i picked him so i’m proud of myself too.
  • more context switching recently. very brain consuming.
  • would like to spend more time on documenting and thinking.

#2

  • 寫日文考古題好有挫折感，目前課程也沒辦法直接解決這問題，看了很多文法章節，但跟解題沒有直接關係，真希望講文法後能直接帶考古題。
  • 背單字也是一樣問題，雖然作業有背單字，但在時間有限的情況下，我可能傾向直接從考古題理學單字。
  • 「應該以考古題為主？還是以課程為主？」

#3

  • 改訂了從 edmonton to vancouver 的飛機，商務艙的費用居然比經濟艙便宜！
  • 應該會挑一個 Quebec City 行程買，因為可以去看瀑布。但不確定是否要住那裡。
    • 住：可以去吃旋轉餐廳
    • 不住：一日遊，起迄都不用安排

#4

  • 「是否該為了用毒練等去搞血裝、和洗點？」
  • 40 等開始練好慢
  • 烏薩奇造型好可愛

#5

下次旅行會去清邁？

Posted on Edited on In 
1
what did i do last week? i barely remember...

#1

1
started playing maplestory artale this weekend.

遊玩的過程中，我再次意識到自己對這款遊戲的執著。

我本來想說骰到什麼就玩什麼而骰到了法師，我也知道舊版應該儘早點魔力擴展，但因為玩的是國際版，看不太懂技能的前置描述，結果點得太晚，導致 MP 沒有最佳化。

「反正只是休閒玩，差那一點 MP 不影響體驗吧？」我試著這樣說服自己。

……但這件事一直如鯁在喉，讓我難以釋懷。

所以隔天，我放棄了那幾小時的進度，重新創角再練了一隻。
目前 31 級，火毒法師。

#2

  • replaced file storage with in-memory storage for user session
  • implemented a new way to release the plugin with compiled files (.pyc)
  • booked accommodations for the Vancouver leg of the trip

#3

I’m glad to share that my pr for “usd survival guide” has been merged!

Posted on Edited on In

「我發現我對於精練之事著迷，例如程式與詩。」

Pseudocode：

1
精煉のことが好きのきついした、プログラミングとか詩とか

如果要保留你原本的語氣，可以改成：

1
精練なものに惹かれる。プログラミングや詩など。

如果想完整表達「我發現自己對精煉的事物著迷，例如程式和詩」這種敘述，可以說：

1
精練なものに惹かれる自分に気づいた。プログラミングや詩など。

「とか〜とか」的正確用法是列舉兩個以上的例子，表現「像～啦～啦這些」的感覺，口語、稍微隨性。
如果想用「プログラミングとか詩とか」這個格式，正確的句子可以像這樣：

1
プログラミングとか詩とか、精練なものに惹かれる

words

惹かれる：ひかれる（hikareru）

📚 小補充：

這是「惹く（ひく）」的被動形。意思是「被吸引、被打動」。

例句：

1
2
彼の言葉に惹かれた。
（被他的話打動了。）

精練：せいれん（seiren）

詩：し（shi）

📖 例句：

1
2
彼の詩は、言葉を精練して生み出された芸術だ。
（他的詩，是經過精煉詞語所誕生的藝術。）

📝 小解析：

  • 「言葉を精練する」= 把用詞打磨得又簡潔又有力。
  • 「生み出す」= 創造、誕生。

整句很有N2考題喜歡的「抽象描述＋具體例子」感覺。

Posted on Edited on In

除草，單純想在這裡 dump 一些想法。

#1

安排班夫行程。火車臥鋪肖貴。還在觀望機票和行程，希望不要售罄

#2

這週處理 3 個任務

Batch convert studiolib data

  • 寫了測試棒棒，之後改動更安心
  • 之後思考有沒有更好的方法，能跟 Maya 解耦
  • integrate with G-drive or other storages

Convert global translation to other controller

  • replace root-hip with global-main
    做功能時，之前寫的測試有幫助到找到忘記一起改的錯誤

Fixed 2 bugs

  • file format reading
  • API response updated
    覺得之前設計的架構讓我很好 debug，修改起來很快

#3

思緒上有點喘不過氣，聽說是職業倦怠的徵兆…
なんか、頭をリセットする方法ないかな。

Posted on Edited on In

What is a tier?

both logical and physical separation of components

Single-tier App

All components are located in the same machine. e.g. Maya, Photoshop…

Pros

  • no network latency
  • privacy data safe since no need to upload users’ data

Cons

  • efficiency bounds on the machine where the app lives on
  • app publisher has no control over the app (users decide whether update the app or not)
  • be vulnerable to being tweaked and reversed engineered

Two-tier App

client-server architecture

Three-tier App

client-backend-database. e.g. blog

N-tier App

What are these components?

  • cache
  • load balancer
  • database
  • queue (for asynchronous behavior)
  • search engine
  • customized business logic services

It is an implementation of the single-responsibility principle

decoupled. it’s easier to maintain. so, for example, we should not store business logic in the database. Also, it is easier to be scaled.

Layer & Tier

layers represent the conceptual/logical organization of the code (code level)

tiers represent the physical separation of components.

Posted on Edited on In

Strategies

Memoization (Top-down)

  1. make it works first
    1. draw the tree
    2. implement & test if the answer is correct (when small cases)
  2. then make it efficient
    1. add a memo with base case return values
    2. store new values in the memo

Tabulation (Bottom-up)

  1. create a table based on the input
  2. fill it with default & base-case values
  3. iterate through to generate the next value based on the current value

Posted on Edited on In

Purpose of this data structure

can search words by prefix in time complexity, O(n).

Recursion Implement

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
package main

import (
	"fmt"
)

type Node struct {
	Keys  map[string]*Node
	IsEnd bool
}

func newNode() *Node {
	return &Node{make(map[string]*Node), false}
}

type Trie struct {
	Root *Node
}

func newTrie() *Trie {
	return &Trie{newNode()}
}

func (t *Trie) Add(str string) {
	Add(str, t.Root)
}

func Add(str string, node *Node) {
	if len(str) == 0 {
		node.IsEnd = true
		return
	} else if _, ok := node.Keys[str[:1]]; ok {
		Add(str[1:], node.Keys[str[:1]])
	} else {
		// create new node for this string
		node.Keys[str[:1]] = newNode()
		Add(str[1:], node.Keys[str[:1]])
	}
}

func (t *Trie) HasWord(str string) bool {
	return HasWord(str, t.Root)
}

func HasWord(str string, node *Node) bool {
	if node.IsEnd && len(str) == 0 {
		return true
	} else if len(str) == 0 {
		return false
	}
	if _, ok := node.Keys[str[:1]]; ok {
		return HasWord(str[1:], node.Keys[str[:1]])
	} else {
		return false
	}
}

func (t *Trie) Words() []string {
	words := []string{}
	Print("", t.Root, &words)
	return words
}

func Print(curr string, node *Node, words *[]string) {
	if node.IsEnd {
		*words = append(*words, curr)
	}
	for key := range node.Keys {
		Print(curr+key, node.Keys[key], words)
	}
}

func main() {
	t := newTrie()
	t.Add("apple")
	t.Add("cat")
	t.Add("category")
	t.Add("")
	fmt.Println(t.Words())
	fmt.Println(t.HasWord("apple"))
	fmt.Println(t.HasWord("none"))
	fmt.Println(t.HasWord("category"))
	fmt.Println(t.HasWord("cat"))
	fmt.Println(t.HasWord(""))
}

output

1
2
3
4
5
6
[ apple cat category]
true
false
true
true
true

Forloop Implement

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
type TrieNode struct {
	Children [26]*TrieNode
	IsEnd    bool
}

type Trie struct {
	Root *TrieNode
}


func Constructor() Trie {
    return Trie{&TrieNode{}}
}


func (this *Trie) Insert(word string) {
	curr := this.Root
	for i := range word {
		// check if has word[i] as a child
		k := word[i] - 'a'
		if curr.Children[k] == nil {
			curr.Children[k] = &TrieNode{}
		}
		curr = curr.Children[k]
	}
	curr.IsEnd = true
}

func (this *Trie) Search(word string) bool {
	curr := this.Root
	for i := range word {
		// check if has word[i] as a child
		k := word[i] - 'a'
		if curr.Children[k] == nil {
			return false
		}
		curr = curr.Children[k]
	}
	return curr.IsEnd
}

func (this *Trie) StartsWith(word string) bool {
	curr := this.Root
	for i := range word {
		// check if has word[i] as a child
		k := word[i] - 'a'
		if curr.Children[k] == nil {
			return false
		}
		curr = curr.Children[k]
	}
	return true
}