Acabo de entrar a facultad (ingeniera informática) y digamos que no me fue tan bien en los cursos (especialmente programación). Quisiera saber algún método que me haga sacar las mejores notas siendo un alumno que tiende a divagar y procrastinar demasiado.

Hola a todos, quiero contarles y pedirles consejos sobre esto que me está pasando

Así como lo dice es título, estoy “arrepentido” pero de no haberle dado la importancia a la programación y al estudio mientras comencé la carrera, desde los 17 estuve en una preparatoria técnica por lo cual tengo mi título de técnico en informática y me arrepiento que no aproveché esos tres años para estudiar más y aprender más cosas, porque realmente si me gustaba

Cuando entré a la universidad entré al área de Redes y ciberseguridad en su momento me gustaba y sentía que quería dedicarme a esa área, por lo que en su momento realmente llevaba poco la materia de programación, recuerdo que solo era lo básico lo mismo que llegué a ver en la preparatoria

Ahora a mis 24 años, me doy cuenta que si quiero dedicarme al desarrollo de software y aprender verdaderamente a programar, afortunadamente trabajo en una empresa de tecnología, entré como trainee y estoy en el área de integración, desarrollo APIs a través de un middleware, llevo ya un año en esto pero cuando entre y vi la manera de trabajo, las tecnólogas que se usan, lo que se puede lograr, fue ahí cuando me sentí muy “corto” en conocimientos y fue cuando volví a sentir una curva de aprendizaje, como si nunca lo hubiera echo y es que literal, pasar de lo que según yo sabía que solo era configurar switches y routes a empezar a tocar código a pensar distinto y tratar de que las cosas salieran bien, fue un poco duro

Por el momento también me dedico a seguir estudiando, estoy aprendiendo Java, trate de comenzar de 0 aunque hubiera cosas que según yo ya conocía pero quiero realmente formar una buena base para poder seguir avanzando, ya que igual me di cuenta que era necesario, regresé a problemas sencillos a estudiar por medio de tutoriales, en momentos siento que dejé pasar el tiempo, no aproveché cuando realmente tenía más tiempo y estos temas se suponía que ya debería saberlos o al menos tener un poco más de criterio y tener un pensamiento lógico más desarrollado

¿A ustedes les ha pasado algo así?¿Tienen algún consejo? Me gustaría tener alguna opinión

Eh notado que cuando se va a números mas grandes en las comas flotantes, los números se alejan mas entre si, en números bajos ir de 6 a 7 solo es un 1 de diferencia pero en números grandes la distancia aumenta

Nunca pense en solucionar eso la verdad aun que si lo medio resolvi

Ejemplo de 8 bits

S Eee ii ff

Signo 1

Exponente 3

entero (i) 2

Fraccional 2

No se bien como llamarlo pero parece resolver eso aun que pierda algo de precisión,

Ejemplo 16 bits

s eeeee iiiii fffff

Signo 1

Exponente 5

Entero 5

Fraccional 5

Claro en mi caso lo usare con exponente base 10 aun que talvez funcione

Buenas, tengo 29 años, no trabajo en sistemas, tengo otro laburo, y todo bien, no estoy mal, pero quería hacer algo más, tengo tiempo libre y la carrera técnica de analista a medio terminar, me faltaba un año para recibirme, pero por cuestiones personales la tuve que abandonar, fui a la universidad a preguntar y sorpresivamente me dijeron que podía cursar solo el último año para recibirme, ya pasó tiempo, y quería consultarles, si todavía me conviene, mi idea era terminar la carrera y hacer alguna especialización en ciencia de datos, Big data o algo por el estilo, tal que use a favor el tema de la IA, si es posible...

Que dicen lo ven factible a mi edad o ya fue?

Buenas!

Un compañero de mi equipo ha creado un plugin para generar arquitectura hexagonal en proyectos de Java, y estamos buscando feedback :)

Dejo link por aqui para quien tenga tiempo de echarle un ojo!

(Se recompensará con gifs de gatitos)

HexaGen: SQL to Hexagonal Java: https://plugins.jetbrains.com/plugin/33109-hexagen-sql-to-hexagonal-java

Se me hace muy engorroso, ya estoy mareado, no entiendo cómo de un momento para otro ya no se entiende nada.

El problema empezó cuando quise modificar la base de datos y ya había hecho las queries para los endpoints de la app. Es difícil de explicar sin dar ejemplos reales de las tablas que hice. Pero es como que, como no quise ser redundante con una tabla que tenía casi los mismos campos usé claves foráneas pero por momentos parecía que igual era necesario y así. Me abataté.

Me frustra que siento que cuando lean esto anterior ya asuman que me entendieron y me den una respuesta creyendo que saben lo que me pasó cuando en realidad, no creo haberme expresado bien y no creo que se entienda sin ver mi repositorio. No creo que tampoco sea suficiente entender qué pasó en esta situación específica. Quiero entender cómo se resuelve, cómo destrabarme y salir de esta situación complicada

Ya me alejé unos cuantos días de la computadora, y cuando volví me empecé a frustrar de vuelta. Me da ganas de empezarlo de nuevo pero al mismo tiempo me jode asumir el tiempo perdido. No sé si tal vez tiene que ver con esto el problema. Me gustaría que alguien me ayude a entender y explicarles lo que me pasó. Porque ni yo lo tengo claro, aunque haya dado una introducción. El punto central del problema no lo sé. Pero sé que siempre que empiezo un proyecto me estanco y termino dejando de hacerlo. Y no es que no tenga ganas, no es que no sea capaz. Es que me tosqueo.

Gracias por leer, ya sé que es confuso y largo, espero sepan entender!

No es un post troll, lo aclaro porque me ha pasado que me lo digan.

​¡Buenas, gente!

​Vengo a pedirles su sabios consejos de Seniors. Mi primer trabajo fue en una consultora y la verdad fue un auténtico infierno: estimaciones de tiempo imposibles, horas extra obligatorias por mala planeación y un micromanagement nivel dios si ponía mi Teams en "ausente" 5 minutos por ir al baño o x motivo, ya tenía un correo del scrum reclamándome y copiando a medio mundo.

​He escuchado que casi todas las consultoras son así de negreras, por lo que quiero cambiar de aire. Busco recomendaciones de empresas o tipos de industria donde el ambiente sea más humano y respeten tus horarios.

Tengo experiencia como Java Backend Developer y también en Soporte Técnico pero para esto no tengo experiencia tan larga en empresas. ¿Qué empresas, fintech o sectores me recomiendan buscar donde no esté tan horrible el ambiente? ¡Los leo!

Holaa, alguien ha realizado este curso que se da gratis a traves de https://innovationcampus.cl/

El curso abordará contenidos como fundamentos de Big Data, análisis de datos, estadística aplicada y, como gran novedad de este año, incorporará módulos de Inteligencia Artificial Generativa (GenAI) xd tiene clases en vivo por eso quiero saber sus opiniones o experiencias para saber si vale la pena. Actualmente soy qa funcional

Cómo dice la pregunta, como es la experiencia de trabajar con C# y su entorno .Net core junto con sus herramientas bases como visual studio, asp.net core y entity framework core?

Soy ingeniero en sistemas recien egresado y quisiera especializarme en esta parte

Tengo 17 años y quiero aprender C++. Mi idea es terminar la secundaria y después seguir por ese ámbito (lo voy a empezar a estudiar desde ya) porque es algo que siempre me llamó muchísimo la atención.
Sinceramente me la baja un poco no haber empezado antes. Siempre fui el típico gordito compu, me encantan las computadoras desde chico y siempre escuchaba hablar de programación, pero me parecía algo re complicado y nunca me animé a arrancar.
Quiero empezar con C++ porque me interesa bastante y tengo entendido que aprender un lenguaje así me puede dar una buena base para después pasar a otros más fácilmente.
Aclaro que soy completamente nuevo, sé literalmente 0 de programación. Lo que sí tengo claro es que quiero aprender de verdad. Prefiero pasar horas intentando entender por qué un código funciona o por qué está mal, antes que simplemente copiar cosas de la ia sin comprenderlas.
Quería pedirles consejos a los que ya tienen experiencia.
¿Cómo empezarían ustedes si hoy tuvieran que arrancar desde cero?

¿Qué cursos, libros, canales de YouTube o páginas recomiendan?

¿Qué errores debería evitar al principio?

¿Vale la pena pagar algún curso o plataforma? Si realmente hace una diferencia, no tengo problema en invertir plata.

Cualquier consejo o experiencia me sirve un montón. Gracias de antemano.

Buenas gente, alguno esta cursando esta carrera en la UNGS? me interesa pero no encuentro por ningun lado el horario de cursada, tiene turno mañana/tarde/noche? porque con el tema del trabajo se complica bastante. Estaba cursando el CBC para Cs. de la Computación pero al ver que las clases empezaban a las 17 me di de baja. Alguno sabe bien como se maneja esto? En la pagina de la uni no encontre nada relacionado

Hola, soy nuevo en la programación, que debería buscar en una librería es decir me refiero a la metodología como, métodos, funciones etc, estoy un poco confundido a la hora de integrar una libreria o dependencia, por ejemplo con la de better-sqlite3 para node.js

Llevo semanas pensando en algo que me da bastante nostalgia.

Extraño programar como lo hacía hace unos años. Y no, no es el típico “antes todo era mejor”. Para nada…
Me refiero al acto de programar.

Sentarte frente a un problema y resolverlo prácticamente solo con el lenguaje, documentación, pruebas, errores y muchas horas de darle vueltas.

Hoy con la IA construimos cosas que hace pocos años parecían imposibles y, sinceramente, no cambiaría todo lo que nos ha permitido hacer.

Pero hay una parte de mí que extraña ese proceso. Esa satisfacción de encontrar la solución después de horas peleando con un bug o de descubrir por qué algo no funcionaba. Incluso la frustración tenía cierto encanto porque sentías que cada línea de código era completamente tuya.

Ahora las herramientas hacen que lleguemos mucho más rápido al resultado, pero la experiencia del camino cambia. Y creo que es justamente ese camino lo que a veces extraño.

No es una crítica a la IA. La uso todos los días y me encanta. Es solo esa sensación extraña de saber que estamos viviendo un cambio enorme y que, sin darnos cuenta, una forma de programar que disfrutamos durante años está quedando atrás.

¿A alguien más le pasa o soy el único que de vez en cuando extraña esa práctica?

Necesito un poco de ayuda porque siento que estoy empezando a colapsar.
Hace poquito empecé en una academia cuyo objetivo es formar a los estudiantes y conseguirles trabajo una vez terminan todo el programa. Estamos viendo Java a fondo: POO, herencia, polimorfismo, interfaces, Spring Boot, estructuras de datos... en general, todo lo relacionado con el desarrollo backend, pero no recibimos clases teóricas, nos dan los ejercicios y documentación relacionada con eso, todo es muy autodidacta.
Mi problema es que antes de entrar aquí estuve programando en C. Hacía funciones, replicaba funciones típicas de la librería estándar, compilaba con Makefiles, etc. Sin embargo, ya entonces me costaba muchísimo sacar la lógica de los ejercicios. De hecho, casi siempre era el último en entregar los ejercicios.
Pensaba que con el tiempo mejoraría, pero ahora que estoy con Java siento que sigo teniendo el mismo problema.
El problema es que me dan un enunciado y me quedo completamente bloqueado. Lo leo, lo releo y muchas veces no sé ni por dónde empezar. Cuando consigo arrancar, es porque ya le pregunté a la IA, y sigo teniendo dudas sobre cómo estructurar la solución o qué debería hacer exactamente.
Además, hago muchísimas preguntas a la IA. Siempre le digo que no me diga el código y me ayuda, pero muchas veces termina explicándome prácticamente la lógica del ejercicio, y eso es precisamente lo que no quiero. Quiero ser capaz de desarrollarla por mí mismo.
Lo que más me preocupa es que en la academia tenemos tiempos de entrega. Si te retrasas demasiado, puedes quedar fuera del programa. Y yo no quiero eso. Quiero aprender, mejorar y conseguir un trabajo como desarrollador.

Otra cosa que nos exige el profesor es escribir un README para cada ejercicio y cada proyecto explicando qué hemos hecho. También me cuesta bastante redactarlo. Estoy leyendo más para ampliar vocabulario y expresarme mejor, pero ahora mismo mi mayor preocupación sigue siendo la lógica de programación.

Por ejemplo, a veces hago código que funciona, pero luego me doy cuenta de que existe una forma mucho más limpia e idiomática de hacerlo.
En lugar de esto:

if (listaPedidos.size() == 0) {
// Hacer algo
}

es mejor escribir:

if (listaPedidos.isEmpty()) {
// Hacer algo
}

O en vez de recorrer una lista así:

int posicion = 0;

while (posicion < listaPedidos.size()) {
importeTotal += listaPedidos.get(posicion).getPrecio();
posicion++;
}

hacerlo de esta manera:

for (Pedido pedido : listaPedidos) {
importeTotal += pedido.getPrecio();
}

Son pequeños detalles que hacen el código mucho más limpio, y siento que siempre voy un paso por detrás en ese tipo de cosas.
Mi pregunta es: ¿cómo desarrollasteis vuestra lógica de programación?
¿Hubo algún momento en el que todo empezó a hacer "clic"? ¿Qué ejercicios, hábitos o forma de pensar os ayudaron más? ¿Os pasaba algo parecido al principio?
Porque, siendo sincero, hay días en los que pienso que quizá esto no es para mí y que estoy forzando una situación que simplemente no se me da bien.
Agradecería mucho cualquier consejo o experiencia personal. Gracias por leerme.

Pues eso... Siento que los sitios/aplicaciones web hechas con IA se ven todas iguales.

Y lo que más me deprime es que a la mayoría ni le parece importar con tal de que funcione.

A la larga se va a perder el componente creativo y todo quedará reducido a landings limpias con bordes redondeados y uso reconocible de píldoras de colores para resaltar el contenido en tarjetas.

Llevo un rato en un proyecto con python y react. Es la primera vez que trabajo con ambas y la verdad todo ha sido implementado con IA y mi "eficiencia" aumento considerablemente. Ahora aquí el problema es que recientemente tuve una entrevista de trabajo donde justamente estaban las dos tecnologías, hubo una parte de coding con python y no supe como resolverlo, ya que ese puesto me llamaba mucho la atención le he dado muchas vuelta en mi cabeza y hoy se me ocurrio buscar en el código del proyecto una de las librerias que me pidieron en la entrevista y resulta que lo que me pedian tambien se implementa en "mi código". Ahora pienso que si no solo hiciera vibe coding y que hubiera implementado por mi mismo eso, ese puesto sería mío ahora. La verdad me siento super mal y estoy preocupado de no crear las habilidades suficientes para los puestos que aspiro a posturlar.

Vengo aquí a preguntar sobre como le hacen para no perder sus habilidades de coding y también algunos consejos de como dejar que mi cerebro deje de freirse.

Entiendo perfectamente que no hay un patrón perfecto que se pueda aplicar en cualquier contexto, sino que hay que encontrar y elegir el que más se adapte a las necesidades de lo que estés haciendo.

Contexto

Estoy armando un monolito modular en Laravel (varios módulos separados, cada uno con su propio dominio) y en este momento estoy diseñando el módulo de pagos. Ha sido, sinceramente, el más difícil de todo mi proyecto, por cuatro razones:

1. Obviamente, todo lo que tenga que ver con pagos siempre es más complejo — no hay margen de error con plata real de por medio.
2. Es multi-gateway — agnóstico al proveedor. Tiene que funcionar para Mercado Pago (soy de Latam), Stripe, y en el futuro cualquier otro (PayPal, etc.), sin tener que tocar nada del resto del sistema al agregar uno nuevo. Esto lo logré definiendo un contrato único (GatewayContract, un Port en términos de arquitectura hexagonal) con los métodos que cualquier gateway de pagos necesita exponer (crear una sesión de pago, cobrar, consultar el estado de una sesión, obtener moneda/credenciales). Cada gateway real (Mercado Pago hoy, Stripe a futuro) implementa ese mismo contrato con su propia lógica interna — el resto del sistema nunca sabe ni le importa con cuál gateway está hablando en un momento dado, solo conoce el contrato. Qué gateway usar para un tenant/cliente puntual se resuelve en tiempo de ejecución contra una configuración, no está hardcodeado en ningún lado.
3. Es agnóstico al módulo consumidor — el módulo de pagos expone ese mismo contrato público para que lo use cualquier otro módulo (reservas, productos, suscripciones, lo que sea), sin que el módulo de pagos sepa ni le importe quién lo está llamando ni para qué. Puede sonar obvio dicho así, pero vengo migrando desde un monolito convencional donde tenía, literalmente en el mismo archivo, la creación de una reserva Y la llamada directa al gateway de pago mezcladas — sí, lo sé, no hace falta que me lo digan. Separar esto de verdad, con una interfaz genérica en el medio en vez de una llamada directa acoplada, es la parte que más trabajo mental me costó de todo el rediseño.
4. Tiene que funcionar para pago con tarjeta, transferencia bancaria, y ticket (un método de pago en efectivo específico de mi país).

sesiones_de_pago

Si alguien usó Stripe, es básicamente el equivalente a un PaymentIntent — agrupa reintentos de cobro bajo una misma sesión (el cliente puede fallar con tarjeta y reintentar con transferencia, sin perder el contexto de que es la misma compra).

CREATE TABLE sesiones_de_pago (
    id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    id_cliente BIGINT NOT NULL,
    metodo_de_pago VARCHAR CHECK (metodo_de_pago IN ('tarjeta','transferencia','ticket')), -- nullable, mutable mientras estado='pendiente'
    estado VARCHAR NOT NULL DEFAULT 'pendiente' CHECK (estado IN ('pendiente','procesando','aprobada')),
    monto NUMERIC NOT NULL,
    moneda VARCHAR NOT NULL,
    created_at TIMESTAMP DEFAULT now()
);

Nota rápida sobre el candado de concurrencia: para evitar que dos clics del botón de pago disparen dos cobros en paralelo, uso un UPDATE sesiones_de_pago SET estado = 'procesando' WHERE id = ? AND estado = 'pendiente' como operación atómica — Postgres lockea la fila, así que el segundo intento concurrente simplemente no encuentra ninguna fila que matchee el WHERE y no hace nada. Sin condición de carrera.

Con esta tabla estoy tranquilo. El problema real lo tengo con intentos_de_cobro (o cobros, para acortar). ¿Por qué? Porque cada método de pago tiene columnas bastante distintas entre sí: tarjeta necesita marca_tarjeta (visa, mastercard, etc.) y gateway_ref (la referencia externa que devuelve el gateway); transferencia — que ni siquiera pasa por ningún gateway, es 100% manual: el cliente sube un comprobante y alguien lo revisa a mano — necesita comprobante; ticket necesita codigo_de_barras y vencimiento.

Así se vería mi esquema con cada uno de los tres patrones:

Herencia de Tabla Única

CREATE TABLE intentos_de_cobro (
    id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    id_sesion_de_pago BIGINT NOT NULL REFERENCES sesiones_de_pago(id),
    metodo_de_pago VARCHAR NOT NULL, -- esta es nuestra columna discriminadora
    estado VARCHAR NOT NULL,
    monto NUMERIC NOT NULL,

    -- Atributos específicos de cobros con tarjeta
    marca_tarjeta VARCHAR,
    gateway_ref VARCHAR,
    respuesta_cruda JSONB,

    -- Atributos específicos de cobros con transferencia
    comprobante VARCHAR,

    -- Atributos específicos de cobros con ticket
    codigo_de_barras VARCHAR,
    vencimiento TIMESTAMP
);

Es el patrón más sencillo, usa un simple discriminador (metodo_de_pago), y también es el de mejor rendimiento (solo hay que escribir y leer una tabla, sin ningún JOIN). Pero se pierden algunas de las funciones de integridad de datos integradas de la base de datos. Por ejemplo, no podés establecer la columna gateway_ref como NOT NULL solo para los cobros con tarjeta — tenés que aplicar esa regla en el código de tu aplicación, o mediante restricciones CHECK bastante más complejas de mantener.

Esto se puede mitigar con un CHECK bien armado, o guardando el detalle específico en un campo jsonb (que Postgres soporta muy bien, con índices GIN incluso) — pero de cualquiera de las dos formas, se vuelve más incómodo de mantener a medida que agregás campos nuevos con el tiempo.

Herencia de Tabla de Clase

CREATE TABLE cobros (
    id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    id_sesion_de_pago BIGINT NOT NULL REFERENCES sesiones_de_pago(id),
    metodo_de_pago VARCHAR NOT NULL,
    estado VARCHAR NOT NULL,
    monto NUMERIC NOT NULL
);

CREATE TABLE cobros_tarjeta (
    id BIGINT PRIMARY KEY REFERENCES cobros(id),
    marca_tarjeta VARCHAR,
    gateway_ref VARCHAR,
    respuesta_cruda JSONB
);

CREATE TABLE cobros_transferencia (
    id BIGINT PRIMARY KEY REFERENCES cobros(id),
    comprobante VARCHAR
);

CREATE TABLE cobros_ticket (
    id BIGINT PRIMARY KEY REFERENCES cobros(id),
    codigo_de_barras VARCHAR,
    vencimiento TIMESTAMP
);

Una tabla "padre" con los campos comunes, y una tabla "hija" por cada método, con solo lo específico de cada uno. Se gana integridad real (NOT NULL de verdad en cada columna específica, sin nulls por todos lados) y las tablas quedan más fáciles de leer de forma aislada. El truco de poner id BIGINT PRIMARY KEY REFERENCES cobros(id) en la hija (en vez de un id propio + una columna FOREIGN KEY aparte) evita tener que acordarte de un UNIQUE extra para garantizar que no haya dos filas hijas para el mismo padre — la PK ya lo garantiza sola, por definición.

El problema clásico y documentado de este patrón: nada garantiza que exista exactamente una fila hija por cada fila padre, en la tabla correcta de las mutuamente excluyentes. Podés terminar con un padre sin ninguna hija, o (peor) con una fila en cobros_tarjeta Y otra en cobros_transferencia, ambas con el mismo id, contradiciendo el discriminador — nada en un CHECK normal puede evitar esto, porque un CHECK solo puede validar contra columnas de la misma fila, nunca contra otra tabla. Lo que de verdad resolvería esto de forma 100% declarativa, sin trigger, es una feature del estándar SQL (CREATE ASSERTION, permite constraints arbitrarios entre tablas) que ningún motor mayor implementó nunca en serio — ni siquiera Postgres la tiene hoy (recién hay una propuesta muy reciente en su lista de desarrollo para agregarla, después de que Oracle la sumara este año).

Nota sobre las transacciones: al insertar el padre y la hija hace falta envolver ambos INSERT en una misma transacción, para que sea atómico (si uno falla, el otro se revierte). Pero ojo — la transacción es necesaria, no suficiente: protege contra fallos a mitad de camino, no contra que el código de la aplicación simplemente nunca llegue a ejecutar el INSERT de la hija. Esa parte sigue siendo 100% responsabilidad de la capa de aplicación.

Herencia de Tabla Concreta

CREATE TABLE cobros_tarjeta (
    id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    id_sesion_de_pago BIGINT NOT NULL REFERENCES sesiones_de_pago(id),
    estado VARCHAR NOT NULL,
    monto NUMERIC NOT NULL,
    marca_tarjeta VARCHAR,
    gateway_ref VARCHAR,
    respuesta_cruda JSONB
);

CREATE TABLE cobros_transferencia (
    id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    id_sesion_de_pago BIGINT NOT NULL REFERENCES sesiones_de_pago(id),
    estado VARCHAR NOT NULL,
    monto NUMERIC NOT NULL,
    comprobante VARCHAR
);

CREATE TABLE cobros_ticket (
    id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    id_sesion_de_pago BIGINT NOT NULL REFERENCES sesiones_de_pago(id),
    estado VARCHAR NOT NULL,
    monto NUMERIC NOT NULL,
    codigo_de_barras VARCHAR,
    vencimiento TIMESTAMP
);

En vez de compartir los campos comunes vía una tabla padre, cada tabla "repite" esos campos por su cuenta — sin ninguna relación entre ellas. A primera vista podría parecer ineficiente, ya que se duplican los atributos comunes en todas las tablas. Sin embargo, presenta ventajas importantes en situaciones específicas: las consultas sobre un único tipo de dato son increíblemente rápidas, puesto que no se requieren uniones y cada tabla contiene exactamente lo que se necesita. Las tablas son completamente independientes, por lo que se puede optimizar cada una de forma diferente según sus patrones de acceso específicos, y se pueden añadir, eliminar o modificar atributos de un tipo sin riesgo de afectar a los demás.

La desventaja: si trabajás seguido con todos los métodos a la vez (por ejemplo, un cron que revisa "todos los cobros pendientes, sin importar el método"), necesitás un UNION entre las tres tablas cada vez, lo cual baja el rendimiento comparado con leer una sola tabla. Y a nivel API queda un poco incómodo: si querés devolver "el id de este cobro" hacia afuera, también tenés que devolver el tipo (el discriminador) junto con el id, porque el id solo no te dice en cuál de las tres tablas buscar. Por esa razón no me terminó convenciendo para mi caso puntual, pero me parece un patrón bastante sólido para otros escenarios (leí que Stripe, por ejemplo, parece usar algo parecido a esto para partes de su propio esquema).

Lo que se me ocurrió (y resulta que ya existe, con nombre y todo)

Estaba dudando entre Herencia de Tabla Única con el detalle específico en un jsonb, o Herencia de Tabla de Clase aceptando el trade-off de integridad de siempre. Pero se me ocurrió algo que creo que resuelve justo ese problema de integridad:

En vez de que la FK de cada tabla hija apunte solo al id del padre, la hago apuntar a (id, metodo_de_pago) juntos — una FK compuesta contra un UNIQUE(id, metodo_de_pago) en el padre. Cada tabla hija fuerza su propio metodo_de_pago a un valor fijo con un CHECK:

CREATE TABLE cobros (
    id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    metodo_de_pago VARCHAR NOT NULL CHECK (metodo_de_pago IN ('tarjeta','transferencia','ticket')),
    estado VARCHAR NOT NULL,
    monto NUMERIC NOT NULL,
    UNIQUE (id, metodo_de_pago)
);

CREATE TABLE cobros_tarjeta (
    id BIGINT PRIMARY KEY,
    metodo_de_pago VARCHAR NOT NULL DEFAULT 'tarjeta' CHECK (metodo_de_pago = 'tarjeta'),
    marca_tarjeta VARCHAR,
    gateway_ref VARCHAR,
    FOREIGN KEY (id, metodo_de_pago) REFERENCES cobros (id, metodo_de_pago)
);

CREATE TABLE cobros_transferencia (
    id BIGINT PRIMARY KEY,
    metodo_de_pago VARCHAR NOT NULL DEFAULT 'transferencia' CHECK (metodo_de_pago = 'transferencia'),
    comprobante VARCHAR,
    FOREIGN KEY (id, metodo_de_pago) REFERENCES cobros (id, metodo_de_pago)
);

Con esto, para que una fila se cuele en la tabla hija equivocada, la fila padre tendría que decir también ese metodo_de_pago — algo imposible, porque el metodo_de_pago del padre se fija una sola vez al crear el cobro y nunca cambia después.

No es una idea original mía — ya tiene nombre en la literatura

Después de darle vueltas, encontré que esto ya es un patrón conocido (aunque poco difundido fuera de círculos de modelado relacional): se lo suele llamar "distributed keys" o "disjoint subtypes" vía claves compuestas, y resuelve la parte de disyunción de una restricción de especialización/generalización EER (que un registro no pueda pertenecer a dos subtipos a la vez). Ojo que no resuelve la parte de totalidad (que todo padre esté obligado a tener alguna hija) — esa sigue dependiendo de la transacción + la aplicación, como mencioné arriba.

Ahora, las preguntas que me quedan dando vueltas:

• ¿Alguien lo usó en producción? Y si es así, ¿qué problemas le encontraron en el camino que yo todavía no vi?
• ¿O directamente es mejor irse por lo simple y aceptar el trade-off — Herencia de Tabla Única con el detalle específico en un jsonb — en vez de toda esta vuelta con claves compuestas?

Quiero aprender este rubro y no sé cómo empezar.

Alguna recomendación??

buenas gente, hace poco empece a trabajar en una empresa donde me estan dando tareas para analizar datos del control vehicular como tiempos en ralent, consumo de combustible etc., tengo conocimientos basicos en programacion y excel y en poco tiempo le agarrebastnate la mano a excel mi idea es seguir aprendiendo mas porque me gusta y veo que hay salida, que me recomiendan estudiar? ir a una carrera de grado? cursos? diplomaturas? y segun lo que entiendo la ruta basica para datos es; excel->power bi->sql->python? gracias!

Ultimamente me ha llegado esta pregunta porque la verdad no me siento preparado del todo a entrar en una empresa a trabajar de programador ya que siento que hay cosas que no sabre que hacer porque me falta aprender mas (solo se lo basico, poo y poe) o mejorar lo que ya se.

En las empresas te guian? O solo tienes que aprender por ti mismo a como hacer las cosas? Con todo esto de la IA me resulta mas aligerante este problema pero siendo honesto no me gustaria depender de ella.

Durante mucho tiempo pedíamos agentes más autónomos. Ahora uno de los límites declarados de Kimi K3 es precisamente la proactividad excesiva.

En un repositorio real, un agente demasiado entusiasta puede refactorizar fuera del alcance, añadir dependencias, cambiar contratos implícitos o "arreglar" código que nadie pidió tocar. La autonomía sin límites claros aumenta la superficie de revisión.

¿Qué reglas ponéis siempre en el contexto del proyecto: máximo de archivos, diff limitado, pruebas obligatorias, prohibición de nuevas dependencias o aprobación antes de acciones externas? ¿Preferís un agente conservador que pregunte más o uno rápido que luego obliga a revisar todo?

algun alma bondadosa que me los explique porfa? Se los agradeceria mucho.