Refactor

Author: CodeHariK

Readme.md

@@ -35,20 +35,38 @@
 
 ## CRDT
 
+
+
+
+https://github.com/nictuku/dht
+https://github.com/shiyanhui/dht
+
+
+
+
+* [Collaborative Text Editing Paper](https://arxiv.org/pdf/2305.00583)
+
+* https://github.com/josephg/crdt-from-scratch
+* https://github.com/josephg/egwalker-from-scratch
+
 * [Collaborative Text Editing with Eg-Walker](https://www.youtube.com/watch?v=rjbEG7COj7o)
 * [Text CRDTs from scratch, in code!](https://www.youtube.com/watch?v=_lQ2Q4Kzi1I)
 * [Lets write Eg-walker from scratch! Part 1](https://www.youtube.com/watch?v=ggXka5TTsOs)
 
+* [Conflict-Free Replicated Data Types (CRDT) for Distributed JavaScript Apps](https://www.youtube.com/watch?v=M8-WFTjZoA0)
 * [CRDTs: The Hard Parts](https://www.youtube.com/watch?v=x7drE24geUw)
 * [CRDTs and the Quest for Distributed Consistency](https://www.youtube.com/watch?v=B5NULPSiOGw)
 * [A CRDT Primer: Defanging Order Theory](https://www.youtube.com/watch?v=OOlnp2bZVRs)
-* [Conflict-Free Replicated Data Types (CRDT) for Distributed JavaScript Apps.](https://www.youtube.com/watch?v=M8-WFTjZoA0)
 
 * [Loro Is Local-First State With CRDT](https://www.youtube.com/watch?v=NB7HRfyufLk)
 * [How Yjs works from the inside out](https://www.youtube.com/watch?v=0l5XgnQ6rB4)
 
+* [CRDTs for Non Academics](https://www.youtube.com/watch?v=vBU70EjwGfw)
 * [An introduction to Conflict-Free Replicated Data Types (CRDTs)](https://www.youtube.com/watch?v=gZP2VUmH05A)
 
+* [CRDT Survey](https://mattweidner.com/2023/09/26/crdt-survey-1.html)
+* [An introduction to state-based CRDTs](https://www.bartoszsypytkowski.com/the-state-of-a-state-based-crdts/)
+
 ## Data Structure
 
 * [Heaps, heapsort, and priority queues - Inside code](https://www.youtube.com/watch?v=pLIajuc31qk)
@@ -81,12 +99,15 @@ Content delivery networks deploy web caches around the world to cache and serve
 
 ### HyperLogLog
 
+* [Wikipedia](https://en.wikipedia.org/wiki/HyperLogLog)
 * [PapersWeLove : HyperLogLog](https://www.youtube.com/watch?v=y3fTaxA8PkU)
 * [The Algorithm with the Best Name - HyperLogLog Explained](https://www.youtube.com/watch?v=2PlrMCiUN_s)
 * [A problem so hard even Google relies on Random Chance](https://www.youtube.com/watch?v=lJYufx0bfpw)
 * [Counting BILLIONS with Just Kilobytes](https://www.youtube.com/watch?v=f69hh3KgFEk)
 * https://github.com/tylertreat/BoomFilters/blob/master/hyperloglog.go
 
+HyperLogLog is an algorithm for the count-distinct problem, Probabilistic cardinality estimators.
+
 ### Count–min sketch
 
 * [Wikepedia](https://en.wikipedia.org/wiki/Count%E2%80%93min_sketch)
@@ -99,7 +120,7 @@ The goal of the basic version of the count–min sketch is to consume a stream o
 
 * [Understanding Probabilistic Data Structures](https://www.youtube.com/watch?v=2Dzc7fxA0us)
 
-### T Digest
+### TDigest
 
 * [Sketching Data with T Digest](https://www.youtube.com/watch?v=ETUYhEZRtWE)
 

datastructure/hyperloglog.go

@@ -1,6 +1,10 @@
 package datastructure
 
-import "github.com/zeebo/xxh3"
+import (
+	"math"
+
+	"github.com/zeebo/xxh3"
+)
 
 type HyperLogLog struct {
 	registers []uint8 // Buckets: each register holds the max number of leading zeros
@@ -34,3 +38,41 @@ func (hll *HyperLogLog) Add(data []byte) {
 		hll.registers[idx] = rank
 	}
 }
+
+func alpha(m int) float64 {
+	switch m {
+	case 16:
+		return 0.673
+	case 32:
+		return 0.697
+	case 64:
+		return 0.709
+	default:
+		return 0.7213 / (1 + 1.079/float64(m))
+	}
+}
+
+func (hll *HyperLogLog) Estimate() float64 {
+	m := float64(len(hll.registers))
+	sum := 0.0
+	zeros := 0
+
+	for _, reg := range hll.registers {
+		sum += 1.0 / float64(uint64(1)<<reg) // 2^-reg
+		if reg == 0 {
+			zeros++
+		}
+	}
+
+	alphaM := alpha(int(m))
+	est := alphaM * m * m / sum
+
+	// 🔥 Small range correction
+	if est <= 5.0*m {
+		if zeros != 0 {
+			est = m * math.Log(m/float64(zeros))
+		}
+	}
+
+	return est
+}

eggwalker/eggwalker.go

@@ -0,0 +1,88 @@
+package eggwalker
+
+import "errors"
+
+type Id struct {
+	agent string
+	seq   int32
+}
+
+func (b *Id) equals(a *Id) bool {
+	return a != nil && b != nil && a.agent == b.agent && a.seq == b.seq
+}
+
+type Item struct {
+	content byte
+
+	id          *Id
+	originLeft  *Id
+	originRight *Id
+
+	deleted bool
+}
+
+type Doc struct {
+	content []Item
+}
+
+func createDoc() Doc {
+	return Doc{
+		content: []Item{},
+	}
+}
+
+func getContent(doc Doc) string {
+	notDeleted := make([]byte, len(doc.content))
+	i := 0
+	for _, item := range doc.content {
+		if !item.deleted {
+			notDeleted[i] = item.content
+			i++
+		}
+	}
+	return string(notDeleted[:i])
+}
+
+func (doc Doc) localInsertOne(
+	agent string,
+	seq int32,
+	pos int32,
+	text byte,
+) {
+	var originLeft *Id
+	if ((pos - 1) > 0) && ((pos - 1) < int32(len(doc.content))) {
+		originLeft = doc.content[pos-1].id
+	}
+	var originRight *Id
+	if (pos > 0) && (pos < int32(len(doc.content))) {
+		originRight = doc.content[pos].id
+	}
+	doc.intergrate(Item{
+		content: text,
+		id: &Id{
+			agent: agent,
+			seq:   seq,
+		},
+		deleted:     false,
+		originLeft:  originLeft,
+		originRight: originRight,
+	})
+}
+
+func findItemIdxAtId(doc Doc, id *Id) (int32, error) {
+	if id == nil {
+		return -1, errors.New("Invalid id")
+	}
+
+	for i := int32(0); int(i) < len(doc.content); i++ {
+		if id.equals(doc.content[i].id) {
+			return i, nil
+		}
+	}
+
+	return -1, errors.New("Item not found")
+}
+
+func (doc Doc) intergrate(newItem Item) {
+	// Add newItem into doc at right location
+}

eggwalker/eggwalker_test.go

@@ -0,0 +1,13 @@
+package eggwalker
+
+import (
+	"testing"
+)
+
+func TestGetContent(t *testing.T) {
+	doc := createDoc()
+	docGetcontent := getContent(doc)
+	if docGetcontent != "" {
+		t.Fatal("It should be empty, got", docGetcontent)
+	}
+}

eggwalker/go.mod

@@ -0,0 +1,3 @@
+module github.com/codeharik/eggwalker
+
+go 1.24.0

go.work

@@ -2,6 +2,7 @@ go 1.24.0
 
 use (
 	./datastructure
+	./eggwalker
 	./lockfree
 	./secretary
 )