El Gebi

getElementById

[Clown World ™ 🤡 @ClownWorld]

Little 💩 thought he was tough 😭 https://t.co/UO7DRP1vm4

[Tom Dörr @tom_doerr]

Workflows for Claude Code to scaffold and deploy projects

https://t.co/tPcvOuFNws

[El CondeNado @elconde_nad0]

Daño físico: 0%
Daño emocional: 100%

[FinoFilipino @FinoFilipino]

El cámara siempre en mi equipo.

[Antiponzista @PonzistaAnti]

Les recomiendo esta pagina, este loko esta remasterizando y adaptando juegos perdidos o abandonados

Desde juegos buenos y clasicos hasta malos, agarro el Call of Juarez 3 por ejemplo que es una poronga y lo dejo "jugable", total

todo gratarola, chusmeen

https://t.co/R3UYFKwm26

[mitsuri @0xmitsurii]

Jensen Huang: I want my engineers to stop coding.

[GitHub Projects Community @GithubProjects]

Google chrome, but no bloat + ad blocker & privacy by default.

[💥LoLo💥 @ZOrtiz9919]

The comments are brutal. 🤣

[Golang News & Libs & Jobs - human 🗣️ , no 🤖 @golangch]

Implements the Outbox Pattern for reliable message delivery in distributed systems, ensuring messages are stored in a database and sent at least once to a message broker (e.g., RabbitMQ, Kafka) with fault-tolerance and transactional integrity.
#golang

https://t.co/AeureByqYB

[Lyes @Chikor_Zi]

I've seen many questions online about how to structure a Go project. The answer is: it depends.

What are you building? Are you collaborating with others? Many patterns are either useful or useless depending on what you're doing and with whom you're doing it.

For example, the standard approach for interacting with a database is to create an interface (repository) that describes interaction methods, and have a DAO (data access object) implement these interactions with a specific database.

The goal of this separation is to make changing the database easy. Your service code calls the database through the interface, so changing the DAO implementation won't affect your code in dependent services. For any third-party dependency, the standard is to wrap it with a repository and use a DAO for it.

When used with dependency injection, this pattern makes unit testing a breeze since you can mock the database and use sample data in your tests.

However, are you really planning on changing the database? This seems like a very difficult thing to do, especially in production. What if you're using PostgreSQL with all its enums, types, and native functions, and decide to switch to MySQL? Many things aren't compatible, you'd have to make a huge number of changes. And let's not even discuss how you'd plan to do this without downtime. This pattern can seem like overkill in many cases.

You shouldn't use a pattern just because it's established or because someone said so. Use a pattern because it's useful.

Layered architecture is a valuable concept because
It works well with Go's package system. Separating concerns lets you focus on one thing at a time

No business logic in the HTTP layer means the HTTP layer handles only input unmarshalling, validation, calling the services, marshalling the DTO, and sending it. Once you separate different parts of logic into different concerns, you'll notice many components that can be automated.

Repository abstraction, to me, is often unnecessary because I've rarely seen anyone change databases unless they were using MongoDB. All the projects I work on use PostgreSQL, and unless we become as large as Meta, we won't need to change the database.

The DAO, however, is a useful abstraction because you want something that wraps your database logic and produces VOs (value objects), which can be DTOs (data transfer objects).

The primary utility of repository interfaces is mocking the DB for unit testing, which I could argue is also less valuable since you're mocking I/O, and integration tests with a test database are generally more effective.

So when to use patterns?

* Need strong compile-time guarantees? Use unit tests. Otherwise, integration and E2E tests often provide better coverage.

* Planning to switch cloud providers or other dependencies? The repository pattern makes sense. If not, direct implementation in services can be simpler.

* Building microservices? Domain-Driven Design offers excellent separation of concerns and bounded contexts.

What distinguishes great engineers is their ability to analyze each situation and choose approaches that deliver the most efficient outcomes rather than blindly following patterns.

[Django News @djangonewsbot]

[Articles] Tips for Tracking Django Model Changes with django-pghistory Efficient database change tracking is achieved by selectively enabling django-pghistory for Django models, optimizing admin integration with EventModelAdmin... #djangonews https://t.co/of9ok8ByZF

[TestDriven.io @testdrivenio]

Python naming conventions:

- class: CamelCase
- variable: lowercase snake_case
- function: lowercase snake_case
- constant: UPPERCASE snake_case
- module: lowercase snake_case
- package: lowercase snake_case
- exception: CamelCase

[Pontoffel_NoPockets (COMMS OPEN) @pontoffelnp]

His work specifically on DOWNLOAD: Devil's Circuit and how he creates both sporadic and naturally confined movement in the characters is crack to me.

[The Go Dev @TheGoDev]

Learn pointers in Go, from memory addresses to practical code examples. A clear guide for every level.

{ author: @musa_fci } #DEVCommunity #GoLang
https://t.co/c6yQyXHMmt

[Anton Putra @antonvputra]

Redis Streams vs Pub/Sub: Performance

https://t.co/jlgwNN1Ufz

[Golang Weekly @GoDiscussions]

I created a video explaining Go concurrency from the ground up using working code examples that each build on top of the previous

https://t.co/DqnMZHiSDw

Discussions: https://t.co/cMWWW81JSw

#golang #programming

[Eyo Eyo, PhD @Eyowhite3]

These games will make learning SQL fun for beginners:

A thread:

[GoLang Trends @GolangTrends]

Most People Don’t Understand Why Go Uses Pointers Instead of References #golang #dormosheio https://t.co/Qve3sz7gyX

[GitHub Projects Community @GithubProjects]

https://t.co/NWggjWIHFq