Forem: Burak Aykan ÜRER

Forget TDD: Are You Accidentally Practicing Fate-Driven Development (FDD)?

Burak Aykan ÜRER — Thu, 23 Oct 2025 08:44:21 +0000

We all talk about methodologies like Test-Driven Development (TDD), Domain-Driven Design (DDD), and Behavior-Driven Development (BDD). But let's be honest: are we truly practicing them, or are we practicing something... else?

My new site, blabladriven.dev, is a hilarious, cynical, and painfully accurate catalog of all the real development methodologies we fall back on when deadlines are tight, specs are hazy, or the universe simply has other plans for our codebase.

It's time to talk about the anti-patterns we all secretly use.

A Few of the Most Painful Methodologies

Here are a few entries from the guide. Which one do you use the most?

🔮 FDD: Fate-Driven Development

The belief that the code's success or failure is predetermined by cosmic forces, making effort largely symbolic.

Core Principle: If the CI/CD pipeline fails three times, it is a sign from the universe to take a break.

Motto: "We pushed to production. Now we wait for Kismet."

🐛 WMMD: 'Works on My Machine' Development

A process that concludes immediately upon seeing the feature successfully execute on the developer’s local environment, regardless of the test suite, staging environment, or user experience.

Core Principle: My machine is the only machine that truly matters.

Motto: "It works on my machine. Everything else is an infrastructure problem."

🧠 IJDS: I Just Did a Google Search Development

The method of building a complex feature entirely from copy-pasted Stack Overflow snippets and the first two search results.

Core Principle: Why write 20 lines of code when 5 lines from the internet will do... until it breaks six months later.

Motto: "I just need to find the right GitHub Gist to fix this."

🤖 CGDD: The 'Can We Just Use ChatGPT' Development

The methodology where the requirements gathering, planning, and initial coding phases are entirely outsourced to an AI model, leaving the developer to debug the output.

Core Principle: AI is better at writing code than I am; I'm better at fixing its mistakes.

Motto: "It passed the linter, but I have no idea what it does."

📣 What's Your Flavor of "Bla-Bla"?

We all have a few of these in our toolkit. It's time to be honest about them.

Check out the full list of anti-patterns and their core principles (including MeDD: Meeting-Driven Development and NDDD: Non-Developer Driven Development) on the site:

👉 The Ultimate Guide to Bla-Bla Driven Development

Which of these methodologies dominates your day-to-day life? And more importantly: What is the most ridiculous "Driven Development" anti-pattern you've ever witnessed?

Share your own in the comments! Let's build the ultimate compendium of developer cynicism.

Spring Data JPA | getOne() vs findById() ! Farkları nedir?

Burak Aykan ÜRER — Wed, 17 Jun 2020 20:38:12 +0000

Spring Data JPA'da getOne() metodu da findById() metodu da bir objeyi getirmek için kullanılabilir. Ancak bu iki metodun çalışma prensibi farklıdır. Bu yazıda bu farklara değineceğim.

- getOne()

getOne() metodu verilen id'ye ait objenin referansını döner. Bu metod içeride EntityManager.getReference() metodunu çağırır. Dökümanda belirtildiği gibi bu metod her zaman database'e gitmeden (lazy fetch) bir proxy döner. İstenen entity'nin database'de bulunmaması durumunda EntityNotFoundException fırlatır.

- findById()

Bu metod ise her çağırıldığında gerçekten database'e gider ve objeyi oradan getirir. Bu EAGER yüklenen işlemdir bu sebeple eğer getirmeye çalıştığımız obje DB'de yoksa null dönecektir.

Hangisini seçmeliyiz ?

Bu iki metodun arasındaki temel fark performans ile ilgili, Lazy Load olan getOne() JVM'den database'e gitmediği için performans olarak findById()'den daha iyidir.

İki metodu da kullanmak için uygun durumlar var. Örneğin objeyi getirip başka bir obje ile ilişki kurmasını sağlamak istediğimizde (OneToOne ya da ManyToOne). Ancak örneğin çağırdığımız objenin içerisinde bulunan başka bir objeye erişmeye çalıştığımızda hata alacağız bu gibi durumlarda findById() metodunu kullanmak daha iyi olacaktır.

findById kullandığımızda

    @PostMapping("/findById/{id}")
    public void findByIdCreate(@PathVariable Long id) {
        Employee employee = new Employee();
        employee.setName("MyEmployee");
        Instant start = Instant.now();
        Department department = departmentRepository.findById(id).get();
        Instant end = Instant.now();
        System.out.println(Duration.between(start, end));
        employee.setDepartment(department);
        employeeRepository.save(employee);
    }

insert yapmadan önce select sorgusu ile Departmanı getiriyoruz arkasından insert metodu 0.004S'de çalışıyor.

Hibernate: select department0_.id as id1_0_0_, department0_.name as name2_0_0_ from Department department0_ where department0_.id=?
PT0.004S
Hibernate: insert into Employee (department_id, name) values (?, ?)

getOne kullandığımızda

    @PostMapping("/getOne/{id}")
    public void getOneCreate(@PathVariable Long id) {
        Employee employee = new Employee();
        employee.setName("MyEmployee");
        Instant start = Instant.now();
        Department department = departmentRepository.getOne(id);
        Instant end = Instant.now();
        System.out.println(Duration.between(start, end));
        employee.setDepartment(department);
        employeeRepository.save(employee);
    }

ise Departman'ın referansını getirdiği için yani aslında database'e gitmediğimiz için işlem çok daha hızlı gerçekleşir.

PT0.002S
Hibernate: insert into Employee (department_id, name) values (?, ?)

getOne()	findById()
Lazy Load ile hedefin referansını getirir	Verilen id'yi gerçekten getirir (referans değil)
Objenin propert'ilerine erişmek gerekmediğinde oldukça kullanışlı	Obje tamamen getirildiği için tüm özelliklerine erişilebilir
Objeye erişmek gerektiğinde obje DB'de yoksa EntityNotFoundException hatası fırlatır	Eğer obje DB'de kayıtlı değilse null döner
Daha iyi performans	İlave bir DB sorgusu gereklidir

Kaynak - Github Proje

Java Validation Annotation'ları

Burak Aykan ÜRER — Fri, 31 Jan 2020 05:03:59 +0000

Spring-Boot uygulamalarında modellerimizi oluştururken validasyon yapabileceğimiz kullanışlı birkaç kütüphane mevcut bu yazıda bunlardan birinden ve kullanabileceğimiz Annotation'lardan bazılarından söz edeceğim. Java Bean'lerinin doğrulanmasında standart framework olarak kullanılan JSR 380'den faydalanacağız.
Kullanıcıdan alacağımız input'lara validasyon uygulamak oldukça temel bir işlem. Bu inputlara doğrulama yapmak bize büyük kolaylık sağlayacaktır.

JSR 380

JSR 380 Bean Validasyonu için bize Java API'si sağlar. Bu versiyon Java 8 ve üzerinde kullanabileceğimiz Optional ve LocalDate'i de destekleyen Annotationlara sahiptir. JSR 380 hakkında daha fazla bilgi almak için bu adrese göz atabilirsiniz.

Dependency

Bu özellikleri kullanmak için dependency'lerinize aşağıdaki dependency'yi eklemeniz yeterli olacaktır.

<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>2.0.0.Final</version>
</dependency>

Gelelim Kullanımına

    @NotNull
    @NotEmpty
    private String username;

@NotNull : Bu annotation'u alan property'nin null olmamasını sağlar, property null olarak set edilmeye çalışıldığında buna engel olacaktır.

@NotEmpty : Özelliğin boş(empty) veya null olmadığını doğrular; String, Collection, Map veya Array'lere uygulanabilir.

    @NotBlank
    private String name;

@notblank : Yalnızca text alanlara uygulanabilir ve özelliğin null olmasını ve whitespace olmasını engeller.

    @AssertTrue
    private boolean itsTrue;

    @AssertFalse
    private boolean itsFalse;

@AssertTrue : Bu annotation'a sahip olan özelliğin true değere olduğunu doğrular.

@AssertFalse : Bu annotation'a sahip olan özelliğin false değere olduğunu doğrular.

    @Email
    private String email;

@Email : Bu annotation'a sahip olan özelliğin geçerli bir e-posta formatına sahip olduğunu doğrular.

    @Min(18)
    @Max(99)
    private int age;

@min - @max : Bu annotationlar property'nin minimum değerden küçük, maksimum değerden büyük olmamasını sağlar.

    @Positive
    private int positive;

    @PositiveOrZero
    private int positiveOrZero;

    @Negative
    private int negative;

    @NegativeOrZero
    private double negativeOrZero;

@positive : Nümerik değerlere uygulanabilir değerin pozitif olmasını zorunlu kılar.

@PositiveOrZero : Nümerik değerlere uygulanabilir değerin pozitif ya da sıfır olmasını zorunlu kılar.

@negative : Nümerik değerlere uygulanabilir değerin negatif olmasını zorunlu kılar.

@NegativeOrZero : Nümerik değerlere uygulanabilir değerin negatif ya da sıfır olmasını zorunlu kılar.

    @Past
    private LocalDateTime pastDate;

    @PastOrPresent
    private LocalDateTime pastOrPresentDate;

    @Future
    private LocalDateTime futureDate;

    @FutureOrPresent
    private LocalDateTime futureOrPresentDate;

@Past : Tarih alanlarına uygulanabilir değerin geçmiş bir tarih olmasını zorunlu kılar. Java 8'de gelen Tarih tiplerine de uygulanabilir.

@PastOrPresent : Tarih alanlarına uygulanabilir değerin geçmiş bir tarih ya da şimdi olmasını zorunlu kılar. Java 8'de gelen Tarih tiplerine de uygulanabilir.

@Future : Tarih alanlarına uygulanabilir değerin gelecek bir tarih olmasını zorunlu kılar. Java 8'de gelen Tarih tiplerine de uygulanabilir.

@FutureOrPresent : Tarih alanlarına uygulanabilir değerin gelecek bir tarih ya da şimdi olmasını zorunlu kılar. Java 8'de gelen Tarih tiplerine de uygulanabilir.

Annotation'lar Collection elemanlarına da uygulanabilir

List<@NotBlank String> preferences;

Annotation'lar için mesaj belirleme

    @Email(message = "Email alanı email formatına uymalıdır")
    private String email;

Annotation'un içine message set edilerek gösterilecek mesaj belirlenebilir.

Ekler

Örnek olarak yazdığım Spring-Boot uygulamasının kodlarını GitHub sayfamda bulabilirsiniz. Bu post orijinalde blogumda yayınlanmıştır.

Point of View as Just Graduated Computer Engineer part1

Burak Aykan ÜRER — Fri, 08 Feb 2019 23:57:34 +0000

I just graduated my school and i get a job about 3 month ago. I just want to share my observations so far the check-points that i noticed so far. At first a couple weeks i tried to learn my company's technologies (Languages, Frameworks e.g.) and learn about our products. First i tried to examine project's code to understand them later watched some courses provided to me by company. Three weeks later from my starting date i assigned to fix minor bugs of a main product. It was very very frightened me this was my first professional experience as a Computer Engineer. I fixed this bugs with my teammates help (Thank you folks!).

Later then that i start to read about these languages and frameworks, tried to find resources as much as i can find.

The points i would like to share with you.Drum roll, please...
I discovered that everyone has their own unique way to learning so my humble opinion please stop and think.

Which way you can learn most efficient?

Which way of learning suits for you?

When you discovered your way you can easily learn anything you want to learn.

I found my way and last a couple weeks was just great for me, learned a lot of things (This excites me a lot).

Like Nietzsche's said: “Ultimately, it is the desire, not the desired, that we love.”

I believe in you folks.

There is a idiom in Turkish: "Sürç-i lisan ettiysem affola" it means: if i misexpressed myself please forgive me. This is my first post so "sürç-i lisan ettiysem affola.

Learn as much as you can and have a nice day.