Awesome. Very cool stuff.

The speaker is an articulate! He managed to deliver a topic which is same as many others, yet provided an unique value to it's viewers. Thanks for the upload. :)

Мало что понял, но очень интересно

"C doesn't need special runtime" - sure, because all the runtime is already inside of Unix! Otherwise `malloc` and `free` would need a runtime.

Where's the source code link for this? Super interesting examples

Cudowne dzięki Jarek 🤟

I feel that the "Generic Data Structures" is a very important, perhaps the most important part of the magic that makes Clojure work (from which "Data-Oriented Programming" is inspired). I invite Java devs to be open minded about trading some type safety for the incredible benefits of generic data structures.

This presentation from Ron Veen surprised me in a very positive way! It begins in a way that I almost clicked the video away though. The point of the talk didn’t became clear for a long time, but I believed in Ron and kept watching. My takeaway here is that finally I see Java making giant leaps towards improvements. I am also for the most part a fan of all “JVM” languages and I’ve been focusing in Kotlin for a while now. Still love Java and still love Scala. Presentations like yours and the new Java versions might represent a turning point in a style discussion we’ve seen in Java vs Kotlin comparison sessions. I see in records a lot of similarities with Kotlin data classes. Other topics like sealed classes and deconstruction also already exist in Kotlin. I wonder what will happen in the coming years to the JVM universe. For now just one more thing, although this is not my favorite in presentation style, this presentation is great in its content! So congrats for this one!👍

An amazing talk! Very concise and precise on such a complex topic while giving just enough details for trade-offs, loved it! You sir deserve an applause

pierwszy

Nice presentation!

A common tenet of "agile" programming is "Test First" / "Test Driven" development that requires writing failing unit-tests before writing each minimal increment of functionality. "Test Soon" rather than "Test First" for development Is my personal recommendation and preference. I.e. In order to fully "flesh-out" the API; Write, and revise (and rewrite, and rewrite again as needed) in parallel: the API the implementation under the API the implementation of the first code that will use the API and then write unit-tests immediately after. "Test First" strategies tend to cause developers to become prematurely invested in a prematurely specified API at a time when the API design needs to be flexible and informed by both the internal implementation and the implementation of the code that will use the API. API Faults, improvements, and unnecessary (yet) functionality will become apparent during its development. The investment in unit tests written up to that point creates a pathological incentive to preserve a prematurely specified API. While an API is being developed, it is important that you be prepared to throw it away and start over (as many times as necessary), and therefor it is important to minimize anything that would make you more reluctant to do that. I.e. while "Test First" strategies emphasize writing tests for each small increment of functionality, after the 30th (small) incremental iteration of initial development, it is very likely that you will find that the API needs to be reworked in a way that would invalidate some (or all) of the unit tests written up to that point. "Test First" Bug Fixing If a bug is found: 1. First develop a "regression" unit test 2. Demonstrate that it can both trigger and detect the problem 3. Fix the bug 4. Demonstrate that the unit-test now passes.

Why would I use Python instead of Julia? Becasue Julia doesn't have tousands of libraries and frameworks that Python has.

Hi, its been a half year, when will you share rest of the videos from GeeCON Prague?

There is a bug in the talk at 21:34: Scala 2 does not support wildcard imports with *, you still have to use _ there.

Mongo Documentation suxxs

Thank you Aleksey!

Screenshot z DS3 FTW :)

No audio

Great talk. Thanks :)

Thanks for this amazing video!! Do not miss out - Promo*SM!

Boring

Nice talk

Good talk, is there a link to source code?

Cool talk but I don't fully understand your principles. So you say that languages/technologies don't matter but at the same time you state you don't like this technology and that technology and so on ...

Why can't you merge ShoppingCart, CartEntity and CartState into single class? I guess that's because ShoppingCart is command handler so better name for it should be ShoppingCartCommandHandler

Strange opinion not to use TestContainers in 2022 because it's slow

What is the advantage of mixing Java and Kotlin code in the Java talk ?

Speakers should be better prepared to the talk

Great talk

Waster of time

No audio?

Haha, love it: "anyone who claims with authority that TDD works is full of crap" 😁

To muj tata 🥹🥹🥹🥹

Thank you 🙏🏽 Amazing resource

very insightful!

excellent

WE WILL DEFFEND OURSELVES!

Seriously man, drink some water before talking, your mouth noise is disgusting

Here, trying to understand whether volatile is also about to deal with processor memory cache.

i was wondering why do u have only one thumb on rating bar and its dislike... there is nothing wrong with ur presentation. So, thumb up.

Honestly I have been looking around to be able to defines my routes and the openAPI documentation at the same time and I could not find nothing up to date or only using Java attributes... This was really painful. I do not understand why tapir is not even mentioned on the lightbend akka http extensions doc page (doc.akka.io/docs/akka-http/current/extensions.html) :(

awesome talk. If you are looking for slides, here it is nurkiewicz.github.io/talks/charbusters/#/

Excellent, finally i grasped the coroutine concept. Thanks!

So far I'm only few minutes into this presentation and I already noticed some logical fallacy- Tomer mentions that nothing in the talk applies specifically to Java, yet whenever I hear anyone complaining about DI that person always turns out to be from the Java ecosystem. In addition Tomer mentions that when thinking about DI people usually think of something like the code presented, yet once again it seems like something Java specific. This is definitely not something that I for instance think of when hearing "Dependency Injection". In fact I don't even know what that code is doing, it seems very weird (I'm a .Net developer if it matters). It looks like the commonly mentioned problems with DI are specific to Java ecosystem, and something must have gone terribly wrong there in the way DI has been implemented. But this should by no means be applied universally to all platforms, or a DI pattern in general.

Great talk! Very practical insights and you can tell it comes from solid, firsthand experience.

If you working on computers you probably can't have cooler name than Cliff Click.