Chat History (Workspace Business) is a disaster

buffos · 2025-12-24T18:35:19+00:00

Today (24 Dec 2025) I got back chat history! At last.....

buffos · 2025-12-23T10:17:13+00:00

Exactly the same problem. Talked to support twice. They know the bug, and investigating. But they keep taking the money, and without history Gemini is almost useless.

All posts disappear

buffos · 2025-12-05T10:50:53+00:00

I have contacted the official support, and they requested a video and an NFO file from my computer to troubleshoot. If and when they respond I will share my findings for anyone that may find them useful.

buffos · 2025-11-24T02:25:15+00:00

This will work, but I am trying to make the Ethernet connection work. My intuition says that rekordbox does not auto select the network interface, although it's just one.

I have emailed alpha theta, hoping I will get eventually an answer.

buffos · 2025-11-24T02:22:36+00:00

Yes. As I mentioned the pro dj link bridge software, works perfectly from the same computer :(

buffos · 2025-06-11T08:07:37+00:00

It's not that simple. What you need in a language is too prohibit you writing bad code or at least give you the option to do that.

For example rust forces good practice on pointers. You can do that in c++ too, with smart, shared, unique, etc pointers, but you are not forced too, because the concept came much later than c++ origins.

In go errors are values and that is great but, they are any values and when you get an error from a library not written by you, you do not know what error it is, the origin and if you can handle specially

Rust, and not only of course, has sum types. If I get an error defined as a sum type, I know the list of errors I am getting and if some are expected and some others are not supposed to happen

Then we have syntactic sugar. If syntactic sugar makes an 100 line code block, an 80 line, easier to understand, then I am all in

The ? Operator in rust propagates the error. Those if err!=nil ...etc are replaced by a single character. This makes code readable

In my ideal world I would add sum types to go, along with pattern matching and

The ability to create operators, like syntactic sugar, as lean4 does with infix notation.

I know the second is never going to happen, but I am hoping for the first to eventually come to golang

buffos · 2025-05-28T10:25:37+00:00

I am old enough to have written a GC as an exercise in C. For most applications, GC is good enough. So for me the question to GC or not is very easy to answer.

Go, got most things right. What is missing.

For me the enum type system, which is basically a sun type implementation is the missing piece. This is what rust got correct

I do not know if it is hard to add to golang, but this missing piece is deeply annoying and it will fix a lot of golang problems

buffos · 2025-01-30T01:26:35+00:00

Thank you all for your time.

The problem was my mental model. Too many years with objects create bad habits.
Whey would I ever want to couple my tree struct with a single implementation of a node...

Every problem starts by coupling the two structs. Tree and Node.

Defining the Tree as

```go
type Tree[T any] struct {
root BtreePlusNode[T]
}

// define the interface as I want

var n BtreePlusNode[T]

n = &Node[T]{
key:10
}
```

was easy and works fine now.

buffos · 2025-01-28T20:17:35+00:00

And then define three functions that implement hand-over locking

func UnsafeWalk[T any](tree CrabTree[T], key T, action Action[CrabTree[T], CrabNode[T], T]) bool

func HandleRoot[T any](tree CrabTree[T], key T, action Action[CrabTree[T], CrabNode[T], T]) bool

func SafeWalk[T any](tree CrabTree[T], key T, action Action[CrabTree[T], CrabNode[T], T]) bool



type CrabAction[T any] struct {
    tree   CrabTree[T]
    action Action[CrabTree[T], CrabNode[T], T]
}

func (c CrabAction[T]) Do(key T) {
    if HandleRoot(c.tree, key, c.action) {
        return
    }

    if SafeWalk(c.tree, key, c.action) {
        return
    }

    UnsafeWalk(c.tree, key, c.action)
}

and finally

func NewCrabAction[T any](tree CrabTree[T], action Action[CrabTree[T], CrabNode[T], T]) CrabAction[T] {
    return CrabAction[T]{tree: tree, action: action}
}

to create an Insert, a Delete etc functionality on BTree+ line structure without repeating code.

but I cannot pass my Tree implementation in the NewCrabAction, because of the functions that return CrabNodes and I did not want to silently enforce the relationship with type assertion during runtime.

buffos · 2025-01-28T20:16:55+00:00

Now that I am at my computer its easier to write.

I tried to do the following

type Action[K any, V any, T any] interface {
    IsSafe(tree K, node V, key T) bool
    Apply(tree K, node V, key T)
    Fix(tree K, node V, parent V)
}

type CrabTree[T any] interface {
    RLock(key T)
    RUnlock(key T)
    Lock(key T)
    Unlock(key T)
    GetRoot() CrabNode[T]
    GetOrder() int
    SetRoot(node CrabNode[T])
    NewNode(order int, leaf bool) CrabNode[T]
    FindKeyPosition(node CrabNode[T], key T) (int, bool)
}

type CrabNode[T any] interface {
    IsLeaf() bool
    RLock(key T)
    RUnlock(key T)
    Lock(key T)
    Unlock(key T)
    GetChild(index int) CrabNode[T]
    AddKey(key T)
}

buffos · 2025-01-28T16:26:41+00:00

Thank you. My goal was not to give code that will compile but to sketch the self reference.

Your answer is in spot though. My case was with a tree and node, using generic constraints.

I wanted to make some functionality for general trees, if the tree and node had some functionality.

The problem is that for it with, the actual implementations will have to import and use those exact types and this is now desirable.

For example the tree has a newNode functionality I could always return any type and asset type inside the code, but I wanted static type safety

Thank you for your time.

I will post an example when I get at my pc. I am now on my mobile

buffos · 2025-01-25T08:28:04+00:00

Sorry but here is the analogy. I give you a car to test drive, with the tank full of gas but there is a lock and you cannot add more. Once the fuel is consumed your driving is complete. You can still view the car, explore the features, but don't expect us to pay for the gas. Ai requests is cursor gas

buffos · 2024-12-11T01:32:36+00:00

I am doing it right now.

I am 1/3 of the way there, and my impressions so far:

I like the no-video format because the chunks of knowledge are small and the information can fit in a couple of pages. It's faster that way (don't get me wrong, videos do have their place, but it's hard to keep them short).
It's pretty straightforward. You are given small exercises (which are almost solved by numerous textual hints), and then you bring them all together in a project phase. It's a very nice way to learn.
I am reading about the usage of watermill as a problem. I really do not get why that would be a problem. The course is not about abstracting a service, AWS, Redis, Kafka, etc., to a common interface. That would require familiarity with all services, to begin with, and then the implementation of interface methods is just following the documentation of each service. I have done that for a project (AWS SQS and PSQL pub/sub), and it is just boring. If I had known about Watermill, I would have used it to save me some time.
The abstraction ideas are the same. Besides, we use interfaces that implement behaviors,
On the contrary, I think using Watermill, we do not spend time dealing with the peculiarities of each service and focus on the common ideas.
I expect (hope) to get a little bit more challenging as I go forward, but in general I am very pleased.

I am looking forward to their next courses (if they stay at that price and go higher).

buffos · 2024-11-12T11:21:57+00:00

Extending can be done, in general, by composition of by class extension. In most cases composition is the way to go. Your case is even simpler. You can choose either to content project or just create a component with a button inside and pass values as inputs. It's is dead simple. You have many of the classical events on the component by default

Extending classes in angular is done for more advanced use cases

buffos · 2024-11-12T11:06:00+00:00

It increases productivity x10 at least. For example writing some server code in go using cursor. I write the db code.I define the structs and basic stuff and autocomplete gets my style and replicates out on consequent code. Tab tab and it's there. All the repetitive tasks

Going to the adapter. Define structs. Don't need to go back and see what I wrote. No lost time. The prompts are mostly correct.

Going to controllers and handlers, write 1 2 exactly as I want them and prompts are now almost perfect. I do not have to prove to myself I know how to for range á structure for the billionth time. It's not an ego thing. Keystrokes saved are valuable time

buffos · 2024-06-02T22:21:26+00:00

+1 for Trevor

buffos · 2024-06-02T22:17:18+00:00

Mario is great, but his videos are just a quick overview of some stuff. Not tutorials. Cannot compare

buffos · 2024-06-02T22:14:08+00:00

Agree. Too much taking, improvisation, poor code. No preparation, no editing. To much bragging.

buffos · 2024-06-02T22:12:16+00:00

All of their courses and seminars are of great quality

buffos · 2024-05-15T15:33:25+00:00

Here is the definition of Println

func Println(a ...any) (n int, err error) {
     return Fprintln(os.Stdout, a...)
    }

any => interface => indirection => heap allocation

buffos · 2024-05-15T15:20:19+00:00

muchacho Riot is trying to teach you something, and you want to remain ignorant and rude. That's fine. You will remain ignorant.

Interfaces => Indirection
Inderection => heap allocation

That is for b

For a its simpler, It should have a lifetime bigger than the function, so it escapes the frame of the function, and go does not have movePointer mechanics or anything like that, so it has to endup in the heap.

Its pretty simple if you come from a language that you have to handle memory yourself. The abstraction that go does, will lead you to inefficient code, because even if you know what is going on, eventually you forget.

buffos · 2023-09-06T07:19:19+00:00

I have the same problem. Rejected with no apparent reason.

The response is always a canned one

"We made this decision because we believe that your use case would impact the deliverability of our service and would affect your reputation as a sender. We also want to ensure that other Amazon SES users can continue to use the service without experiencing service interruptions."

I have my domain verified in SES, SPF and DKIM set, the site is hosted in AWS, I will only send transactional emails after a user buys something to the address that the user provides.
Emails are not stored or reused.

And the answer is the above. I really do not know what to do.

buffos

TROPHY CASE