Sedose

// org/example/Main.kt

package org.example

import org.mapstruct.Mapper
import org.mapstruct.control.DeepClone
import org.mapstruct.factory.Mappers

@Mapper(mappingControl = DeepClone::class)
interface DeepCopyMapper {

Sedose

import java.io.OutputStream
import java.io.PrintStream

inline fun <T> withSystemOutRedirectedTo(stream: OutputStream, block: () -> T): T {
  val originalOut = System.out
  System.setOut(PrintStream(stream))
  return try {
    block()
  } finally {
    System.setOut(originalOut)

Sedose

(ns bmi-calculator.core)

(defn calculate-bmi [weight-kg height-m]
  (/ weight-kg (* height-m height-m)))

(defn classify-bmi [bmi]
  (cond
    (< bmi 18.5) "Underweight"
    (< bmi 24.9) "Normal weight"
    (< bmi 29.9) "Overweight"

Sedose

SELECT
    table_schema,
    table_name,
    string_agg(column_name, ', ' ORDER BY ordinal_position) AS columns
FROM information_schema.columns
WHERE table_schema NOT IN ('information_schema', 'pg_catalog')
GROUP BY table_schema, table_name
ORDER BY table_schema, table_name;

Sedose

Prefer composition over implementation inheritance principle

https://en.wikipedia.org/wiki/Composition_over_inheritance

Inheritance: https://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)

Composition: https://en.wikipedia.org/wiki/Object_composition

Aggregation: https://www.youtube.com/watch?v=pqQAHA1XjJk

Sedose

This document explains why teams commonly choose JPA/Hibernate and when they might prefer alternatives like jOOQ, QueryDSL, or Kotlin Exposed.

Why Teams Default to JPA/Hibernate

• De-facto standard for Java/Kotlin ORM - widely known and supported • Library integration - many tools assume or work with JPA • Boilerplate reduction - handles simple CRUD and domain models well

When Teams Choose Alternatives

Sedose

Pessimistic vs. Optimistic Locking in PostgreSQL

This document explains the differences between pessimistic and optimistic locking in PostgreSQL, their trade-offs, and when to use each approach.

Overview

Pessimistic and optimistic locking are two strategies for handling concurrent data updates. Both ensure data consistency but differ in conflict handling and performance implications.

Pessimistic Locking

Core Idea

Sedose

import java.io.File
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit

const val REPO_PATH = "/path/to/your/repo"
const val BRANCH_NAME = "develop"
const val REMOTE_NAME = "origin"
const val INTERVAL_SECONDS = 3600L

fun updateBranch() = File(REPO_PATH).takeIf { it.isDirectory }?.let { repoDir ->

Sedose

package org.example

fun main() {
    val root = TreeNode(15).apply {
        left = TreeNode(6).apply {
            left = TreeNode(4)
            right = TreeNode(9).apply {
                left = TreeNode(7)
            }
        }

Sedose

fn main() {}

pub struct Solution;

impl Solution {
    pub fn license_key_formatting(input: String, k: i32) -> String {
        let input: String = input
            .chars()
            .filter(|&c| c != '-')
            .map(|c| c.to_ascii_uppercase())