Log for OwO

妈妈我上电视了，快看

我觉得我可以改行当rom开发者了

改改改，都改

那些年，我可能是首批在马国尝试 Ubuntu Touch ROM 的人

这些年我可是首批在马国尝试linage os的人

不惜牺牲电话保固，爽下去

你也改太多行惹吧wwwwww

/go@mmis_js_bot package main

import (
"fmt"
"log"
"os/exec"
)

func main() {
out, err := exec.Command("uuidgen").Output()
if err != nil {
log.Fatal(err)
}
fmt.Printf("%s", out)
}

不然這樣好了，這隻 BOT 到底有什麼可以用的

/go@mmis_js_bot package main

import (
"fmt"
"log"
"os/exec"
)

func main() {
out, err := exec.Command("uuidgen").Output()
if err != nil {
log.Fatal(err)
}
fmt.Printf("%s", out)
}

// SetVersion sets version bits.
func (u *UUID) SetVersion(v byte) {
u[6] = (u[6] & 0x0f) | (v « 4)
}

// SetVariant sets variant bits as described in RFC 4122.
func (u *UUID) SetVariant() {
u[8] = (u[8] & 0xbf) | 0x80
}

// MarshalText implements the encoding.TextMarshaler interface.
// The encoding is the same as returned by String.
func (u UUID) MarshalText() (text []byte, err error) {
text = []byte(u.String())
return
}

// UnmarshalText implements the encoding.TextUnmarshaler interface.
// Following formats are supported:
// "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
// "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}",
// "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8"
func (u *UUID) UnmarshalText(text []byte) (err error) {
if len(text) < 32 {
err = fmt.Errorf("uuid: UUID string too short: %s", text)
return
}

t := text[😏
braced := false

if bytes.Equal(t[:9], urnPrefix) {
t = t[9😏
} else if t[0] == '{' {
braced = true
t = t[1😏
}

b := u[😏

for i, byteGroup := range byteGroups {
if i > 0 {
if t[0] != '-' {
err = fmt.Errorf("uuid: invalid string format")
return
}
t = t[1😏
}

if len(t) < byteGroup {
err = fmt.Errorf("uuid: UUID string too short: %s", text)
return
}

if i == 4 && len(t) > byteGroup &&
((braced && t[byteGroup] != '}') || len(t[byteGroup😏) > 1 || !braced) {
err = fmt.Errorf("uuid: UUID string too long: %s", text)
return
}

_, err = hex.Decode(b[:byteGroup/2], t[:byteGroup])
if err != nil {
return
}

t = t[byteGroup😏
b = b[byteGroup/2😏
}

return
}

// MarshalBinary implements the encoding.BinaryMarshaler interface.
func (u UUID) MarshalBinary() (data []byte, err error) {
data = u.Bytes()
return
}

// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
// It will return error if the slice isn't 16 bytes long.
func (u *UUID) UnmarshalBinary(data []byte) (err error) {
if len(data) != 16 {
err = fmt.Errorf("uuid: UUID must be exactly 16 bytes long, got %d bytes", len(data))
return
}
copy(u[😏, data)

return
}

// Value implements the driver.Valuer interface.
func (u UUID) Value() (driver.Value, error) {
return u.String(), nil
}

// Scan implements the sql.Scanner interface.
// A 16-byte slice is handled by UnmarshalBinary, while
// a longer byte slice or a string is handled by UnmarshalText.
func (u *UUID) Scan(src interface{}) error {
switch src := src.(type) {
case []byte:
if len(src) == 16 {
return u.UnmarshalBinary(src)
}
return u.UnmarshalText(src)

case string:
return u.UnmarshalText([]byte(src))
}

return fmt.Errorf("uuid: cannot convert %T to UUID", src)
}

// Value implements the driver.Valuer interface.
func (u NullUUID) Value() (driver.Value, error) {
if !u.Valid {
return nil, nil
}
// Delegate to UUID Value function
return u.UUID.Value()
}

// Scan implements the sql.Scanner interface.
func (u *NullUUID) Scan(src interface{}) error {
if src == nil {
u.UUID, u.Valid = Nil, false
return nil
}

// Delegate to UUID Scan function
u.Valid = true
return u.UUID.Scan(src)
}

// FromBytes returns UUID converted from raw byte slice input.
// It will return error if the slice isn't 16 bytes long.
func FromBytes(input []byte) (u UUID, err error) {
err = u.UnmarshalBinary(input)
return
}

// FromBytesOrNil returns UUID converted from raw byte slice input.
// Same behavior as FromBytes, but returns a Nil UUID on error.
func FromBytesOrNil(input []byte) UUID {
uuid, err := FromBytes(input)
if err != nil {
return Nil
}
return uuid
}

// FromString returns UUID parsed from string input.
// Input is expected in a form accepted by UnmarshalText.
func FromString(input string) (u UUID, err error) {
err = u.UnmarshalText([]byte(input))
return
}

/go@mmis_js_bot package uuid

import (
"bytes"
"crypto/md5"
"crypto/rand"
"crypto/sha1"
"database/sql/driver"
"encoding/binary"
"encoding/hex"
"fmt"
"hash"
"net"
"os"
"sync"
"time"
)

// UUID layout variants.
const (
VariantNCS = iota
VariantRFC4122
VariantMicrosoft
VariantFuture
)

// UUID DCE domains.
const (
DomainPerson = iota
DomainGroup
DomainOrg
)

// Difference in 100-nanosecond intervals between
// UUID epoch (October 15, 1582) and Unix epoch (January 1, 1970).
const epochStart = 122192928000000000

// Used in string method conversion
const dash byte = '-'

// UUID v1/v2 storage.
var (
storageMutex sync.Mutex
storageOnce sync.Once
epochFunc = unixTimeFunc
clockSequence uint16
lastTime uint64
hardwareAddr [6]byte
posixUID = uint32(os.Getuid())
posixGID = uint32(os.Getgid())
)

// String parse helpers.
var (
urnPrefix = []byte("urn:uuid:")
byteGroups = []int{8, 4, 4, 4, 12}
)

func initClockSequence() {
buf := make([]byte, 2)
safeRandom(buf)
clockSequence = binary.BigEndian.Uint16(buf)
}

func initHardwareAddr() {
interfaces, err := net.Interfaces()
if err == nil {
for _, iface := range interfaces {
if len(iface.HardwareAddr) >= 6 {
copy(hardwareAddr[😏, iface.HardwareAddr)
return
}
}
}

// Initialize hardwareAddr randomly in case
// of real network interfaces absence
safeRandom(hardwareAddr[😏)

// Set multicast bit as recommended in RFC 4122
hardwareAddr[0] |= 0x01
}

func initStorage() {
initClockSequence()
initHardwareAddr()
}

func safeRandom(dest []byte) {
if _, err := rand.Read(dest); err != nil {
panic(err)
}
}

// Returns difference in 100-nanosecond intervals between
// UUID epoch (October 15, 1582) and current time.
// This is default epoch calculation function.
func unixTimeFunc() uint64 {
return epochStart + uint64(time.Now().UnixNano()/100)
}

// UUID representation compliant with specification
// described in RFC 4122.
type UUID [16]byte

// NullUUID can be used with the standard sql package to represent a
// UUID value that can be NULL in the database
type NullUUID struct {
UUID UUID
Valid bool
}

// The nil UUID is special form of UUID that is specified to have all
// 128 bits set to zero.
var Nil = UUID{}

// Predefined namespace UUIDs.
var (
NamespaceDNS, _ = FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
NamespaceURL, _ = FromString("6ba7b811-9dad-11d1-80b4-00c04fd430c8")
NamespaceOID, _ = FromString("6ba7b812-9dad-11d1-80b4-00c04fd430c8")
NamespaceX500, _ = FromString("6ba7b814-9dad-11d1-80b4-00c04fd430c8")
)

// And returns result of binary AND of two UUIDs.
func And(u1 UUID, u2 UUID) UUID {
u := UUID{}
for i := 0; i < 16; i++ {
u[i] = u1[i] & u2[i]
}
return u
}

// Or returns result of binary OR of two UUIDs.
func Or(u1 UUID, u2 UUID) UUID {
u := UUID{}
for i := 0; i < 16; i++ {
u[i] = u1[i] | u2[i]
}
return u
}

// Equal returns true if u1 and u2 equals, otherwise returns false.
func Equal(u1 UUID, u2 UUID) bool {
return bytes.Equal(u1[😏, u2[😏)
}

// Version returns algorithm version used to generate UUID.
func (u UUID) Version() uint {
return uint(u[6] » 4)
}

// Variant returns UUID layout variant.
func (u UUID) Variant() uint {
switch {
case (u[8] & 0x80) == 0x00:
return VariantNCS
case (u[8]&0xc0)|0x80 == 0x80:
return VariantRFC4122
case (u[8]&0xe0)|0xc0 == 0xc0:
return VariantMicrosoft
}
return VariantFuture
}

// Bytes returns bytes slice representation of UUID.
func (u UUID) Bytes() []byte {
return u[😏
}

// Returns canonical string representation of UUID:
// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
func (u UUID) String() string {
buf := make([]byte, 36)

hex.Encode(buf[0:8], u[0:4])
buf[8] = dash
hex.Encode(buf[9:13], u[4:6])
buf[13] = dash
hex.Encode(buf[14:18], u[6:8])
buf[18] = dash
hex.Encode(buf[19:23], u[8:10])
buf[23] = dash
hex.Encode(buf[24😏, u[10😏)

return string(buf)
}

// FromStringOrNil returns UUID parsed from string input.
// Same behavior as FromString, but returns a Nil UUID on error.
func FromStringOrNil(input string) UUID {
uuid, err := FromString(input)
if err != nil {
return Nil
}
return uuid
}

// Returns UUID v1/v2 storage state.
// Returns epoch timestamp, clock sequence, and hardware address.
func getStorage() (uint64, uint16, []byte) {
storageOnce.Do(initStorage)

storageMutex.Lock()
defer storageMutex.Unlock()

timeNow := epochFunc()
// Clock changed backwards since last UUID generation.
// Should increase clock sequence.
if timeNow <= lastTime {
clockSequence++
}
lastTime = timeNow

return timeNow, clockSequence, hardwareAddr[😏
}

// NewV1 returns UUID based on current timestamp and MAC address.
func NewV1() UUID {
u := UUID{}

timeNow, clockSeq, hardwareAddr := getStorage()

binary.BigEndian.PutUint32(u[0😏, uint32(timeNow))
binary.BigEndian.PutUint16(u[4😏, uint16(timeNow»32))
binary.BigEndian.PutUint16(u[6😏, uint16(timeNow»48))
binary.BigEndian.PutUint16(u[8😏, clockSeq)

copy(u[10😏, hardwareAddr)

u.SetVersion(1)
u.SetVariant()

return u
}

// NewV2 returns DCE Security UUID based on POSIX UID/GID.
func NewV2(domain byte) UUID {
u := UUID{}

timeNow, clockSeq, hardwareAddr := getStorage()

switch domain {
case DomainPerson:
binary.BigEndian.PutUint32(u[0😏, posixUID)
case DomainGroup:
binary.BigEndian.PutUint32(u[0😏, posixGID)
}

binary.BigEndian.PutUint16(u[4😏, uint16(timeNow»32))
binary.BigEndian.PutUint16(u[6😏, uint16(timeNow»48))
binary.BigEndian.PutUint16(u[8😏, clockSeq)
u[9] = domain

copy(u[10😏, hardwareAddr)

u.SetVersion(2)
u.SetVariant()

return u
}

// NewV3 returns UUID based on MD5 hash of namespace UUID and name.
func NewV3(ns UUID, name string) UUID {
u := newFromHash(md5.New(), ns, name)
u.SetVersion(3)
u.SetVariant()

return u
}

// NewV4 returns random generated UUID.
func NewV4() UUID {
u := UUID{}
safeRandom(u[😏)
u.SetVersion(4)
u.SetVariant()

return u
}

// NewV5 returns UUID based on SHA-1 hash of namespace UUID and name.
func NewV5(ns UUID, name string) UUID {
u := newFromHash(sha1.New(), ns, name)
u.SetVersion(5)
u.SetVariant()

return u
}

// Returns UUID based on hashing of namespace UUID and name.
func newFromHash(h hash.Hash, ns UUID, name string) UUID {
u := UUID{}
h.Write(ns[😏)
h.Write([]byte(name))
copy(u[😏, h.Sum(nil))

return u
}

func main(){
u1 := uuid.NewV4()
fmt.Printf("UUIDv4: %s\n", u1)
}

為什麼 seadog上的DB最後到這

3小

/go@mmis_js_bot package main

import (
"fmt"
"log"
"os/exec"
"time"
)

func main() {
fmt.Println(time.Second)
}

這也要管

/go@mmis_js_bot package main

import (
"fmt"
"time"
)

func main() {
fmt.Println(time.Second)
}

Go 編譯很快就是因為：

1. 你不能放沒有用到的變數
2. 你不能放沒有用到的套件

wwwww

/go@mmis_js_bot package main

import (
"fmt"
"time"
)

func main() {
fmt.Println(time.Second)
}

誒誒

沒看到

Go 編譯到啟動的速度差不多跟啟動一個 Node.js Ghost Blog 一樣

不是阿 Go compiler不能直接無視嗎

就像無是註解一樣

不能，會強迫你要把沒用到的東西拿掉

頂多提出Warn阿

腦護航。

幹嘛直接發ERR

因為這樣編譯比較快

ERR 後還不給 result

你說直接噴錯嗎

提出Warn一樣阿

？

提出 Warn 不就代表被編譯了嗎

對阿

就是 警告你有沒用的東西 但是照樣給你編

但是這樣的話就會縱容太多人吧？

會慢，拿掉重編比較快

最好是這樣啦www

🌚

像是 Go 原本在 1.8 加入的 Alias

這是家長式編譯器

你大可說，不想用的人不要用

但是一但你縱容、允許了，就有人會亂用

看看 PHP 那麼自由，現在被一堆人討厭的要死 🌚

你不會有時候寫到一半想先編編看嗎

不是因为自由啦

那個⋯⋯VSCode 會自動幫你先編譯喔。

然而你很喜歡

你不用自己每次手動編譯的。

因為 Go 編譯速度很快嘛 🌚👉

只要存個檔案，就會有 Go 在背後幫你編譯，然後你可以即時在 IDE 上看到錯誤提示

设计真棒～

真棒刚写完代码就丢失了😅

哪一个比较好呢？😕

左邊

👉

但是可能要加個分隔線

🌚👎

卡片是用來給你當卡片的

還是說你這已經是 List Item 了

不是都一样吗，设计不同而已

用card眼睛比较没那么吃力

該用什麼東西的時候就給我用那個東西啊喂wwww

额，对我来说card==list ，两个都能click

新element card list

oops 那个该死的inspect

你這陰影怎麼這麼沈重

你用哪個套件？

我還以為是 Android App
原來是 web

CSS~

有人被骗惹

包一包，Android App。

css也可以控制程式UI?

就是程式語言內，可以用css控制GUI的外觀這樣

不
是整組UI用CSS寫的

css也太強大

是說 你主要寫什麼的阿

C嗎

Verilog (硬體的語言xd)

喔喔 好 喔

这是app

偶而會用perl整理硬體的code

那 主要寫哪方面的

數位電路～

好喔

幾歲阿

28

老人(#

我的高中有個說法，畢業後就老人了xdrz

是的小孩～

最后决定不放shadow

都透明了幹嘛還穿wwwww

這太色情了吧 他手的那個動作

這東西有人用過嗎?

有點好奇文字轉語音拿Nodejs搞的狀況。然後中研院那個根本聽不懂...

剛剛在C9上弄惹ouo

umm

https://blog.allenchou.cc/node-js-tts/
是有看過某Allen的BLOG曾經有過這文章，但是想看的時候死站了?

目前是噴噴噴(?

@Tex1323 你的flatUI。。。

什么东西

Error: kill ESRCH Orz

\明天嘗試/

\明天嘗試/

\ouo/

\ouo/