> Sure but it's not gonna happen. The Dart team already stated it many times. I don't think we actually did state that anywhere. Appeal of such feature (e.g. automatic synthesis of hashCode, equals, toString) is pretty clear.

Still writing 50 lines of Java boilerplate just to hold data? Java Records fix this in one line Behind the scenes, you instantly get: • Constructor • Getters • toString() • equals & hashCode Immutable & clean. #CtrlPlusCode #Java #Coding

Even PMO website is not safe, they are using MD5, open salted hashcode, and sha256 open library version 0.0.8 authored by Chinese developer. Whole site very easy to crack using rainbow tables and modern gcp

Even PMO website using MD5 snd open salted hashcode, 🤫

döp-dödö-döp der Hashcode der Revolution lol

2/ Collections Framework A lot of Java interviews are secretly collection interviews. HashMap, ArrayList, LinkedList, HashSet, TreeMap, ConcurrentHashMap. You should know how they work internally, when to use what, time complexity, resizing, hashing, collision handling and why bad equals/hashCode can destroy your application. Java engineers who understand collections write much better code.

1/ Core Java Fundamentals Most people jump to Spring Boot too early. But real Java skill starts with the basics: OOP, interfaces, abstract classes, generics, exceptions, collections, immutability, equals/hashCode, records, enums, streams and optionals. If your fundamentals are weak, Spring Boot will only help you hide the confusion for sometime.

🚨 BREAKING: Hashcode is NOT expected to go to the FIFA World Cup. @PoojaMedia

If you want to master Java fast? Stop “learning Java” and start shipping small things daily. 1. Core syntax OOP: classes, interfaces, generics, immutability 2. Collections: List/Map/Set, equals/hashCode, iterators, Big-O basics 3. JVM basics: memory, GC, stack vs heap, classloading (at least conceptually) 4. Concurrency: threads, executors, synchronized/locks, CompletableFuture 5. I/O: files, streams, NIO, serialization pitfalls 6. Testing: JUnit, mocking, writing tests for bugs you just fixed 7. Build/tools: Maven or Gradle, logging (SLF4J), debugging in IDE 8. Modern Java: streams, Optional, records, sealed classes (know when not to use them) Rule: 60 mins reading, 120 mins coding, 30 mins debugging every day. Pick one backend project (REST API DB) and use it to practice every topic.

其实你看像并发库和日期库这样多套 API，影响也没想象中的那么大。 Java 早期很多决策都“很有问题”的，比如每个对象都有一个对象锁，现在费劲巴拉去尝试缩减对象头。默认的 hashcode 和 equal 实现也常挖坑。装箱拆箱更是走了好远的弯路，最近才开始做原生类型可用于泛型参数。 很多决策是历史遗留问题，真的很难改了。只能重新发明一个然后新项目用新方案，逐步淘汰旧方案。 Rust 也有一些问题，比如现在看起来依赖 LLVM 和 GLIBC 其实不如 Golang 那样手写 linker 和系统调用包装。但是当时这么选的话可能根本难产死了。比如 async rust 有海量的问题，其中比较轻微但又明显的问题就是 waker 的错误设计。实际上所有人实现 waker 都是一个指针，都是 cheap clone，所以 wake_by_ref 完全是想太多。然后所有 waker 基本都要做重复 wake 过滤，所以 will_wake 很多时候也只是让人写不必要的检查。 继续，Pin 的作者 withoutboat 自己承认这个方案是为了发 1.0 的折中，实际应该设计一套 Movable 的 Auto Trait 对整个编译器更好。再比如 Java 的 finalize 有海量的问题，终于在 Java 9 里正式废弃通告所有用户不要实现不要依赖就当它不存在。 这样的事情数都数不完..回到泛型设计上说，Java 为了兼容旧库，导致泛型残疾，有很多表意会出问题，这个大家写过都遇到过。而且因为类型擦除，编译器也没有做特化，导致你要真的运行时处理这个泛型信息，必须额外传入一个 Class<T> 参数，即使传了，也很难用。

Que de temps gagné avec l'IA... Claude m'a codé un tool en C# pour renommer un répertoire de photos (dont les noms étaient des hashcode automatiquement généré), en fichiers Image_XXX.jpg d'après leur date de prise de vue (puisée dans l'EXIF donc à la seconde prêt). ça a pris 5mn.

What are Java Records? Java records were introduced as a preview feature in Java 14 (JEP 359) and finally released as a permanent feature in Java 16 (JEP 395).  A record is a special type of class designed to hold immutable data. public record Product(String name, double price) {} Here, a single line of code will help with private final fields, a constructor that takes all the fields, getter methods, and auto-generated toString(), equals(), and hashCode() methods.

swift-hash-primitives — Hash.Protocol with borrowing hash(into:), refining Equation.Protocol so equals/hashCode is a type-level invariant. Hash.Value is a typed wrapper for hash output. Typealiases to Swift.Hashable on 6.4 . swift-institute.org/document…

🚀Java: Starting from Java 14, you can use records to create short, immutable, data-carrying objects. ✅ They are shorter than ordinary POJOs ✅ They have built-in equals(), hashCode(), toString() ✅ They are immutable by default #JavaDev #Records

Day 14 of backend dev💻 Covered lecture 22 from @CoderArmy - Object class - equals() vs==difference -hashCode() and its importance in HashMap working -clone() method and concept of shallow vs deep copy @adityatandon02 @rohit_negi9 #Java #BackendDevelopment #CodingJourney #OOP

POJO Plain Java Object — no framework rules. JavaBean POJO conventions: private fields, getters/setters, no-arg constructor. Spring Bean Object managed by Spring container (lifecycle DI). Entity Maps to DB table (JPA/Hibernate). DTO Data carrier between layers (no business logic). VO (Value Object) Immutable, represents a value (equals by data, not identity). DAO Data access layer (DB operations). BO (Business Object) Contains business logic. Record Immutable data class (Java 16 ) with built-in equals/hashCode/toString. Same language. Different responsibilities.

Mis razones para no recomendar el uso de project Lombok serían: 1. Oculta código real (pierdes claridad y transparencia). 2. Aumenta la curva de entrada para nuevos devs. 3. Depende de hacks del compilador (puede romper con updates de Java). 4. Problemas con IDEs/debugging en algunos casos. 5. Dificulta el mantenimiento a largo plazo. Hace más difícil razonar sobre el dominio (especialmente con @ Data). 6. Genera magia innecesaria cuando Java ya evolucionó (records, etc.). 7. Puede causar bugs sutiles (equals/hashCode mal generados, builders inconsistentes). 8. Acopla tu código a una librería no estándar. 9. Complica integraciones con herramientas (análisis estático, frameworks, etc.).

Si bro te entiendo, básicamente mis razones para no recomendar Lombok serían: 1. Oculta código real (pierdes claridad y transparencia). 2. Aumenta la curva de entrada para nuevos devs. 3. Depende de hacks del compilador (puede romper con updates de Java). 4. Problemas con IDEs/debugging en algunos casos. 5. Dificulta el mantenimiento a largo plazo. Hace más difícil razonar sobre el dominio (especialmente con @ Data). 6. Genera magia innecesaria cuando Java ya evolucionó (records, etc.). 7. Puede causar bugs sutiles (equals/hashCode mal generados, builders inconsistentes). 8. Acopla tu código a una librería no estándar. 9. Complica integraciones con herramientas (análisis estático, frameworks, etc.). Sin embargo entiendo que se use, tampoco es el fin del mundo. Solo que yo no la recomiendo y evito usarla.

Did you know? 💡 Java’s HashSet is actually a HashMap in disguise. 🎭 It sounds counterintuitive—why use a complex Key-Value pair structure when you only care about a single value? But the reason is a masterclass in software engineering efficiency. 🕵️ The Internal "Secret" When you call new HashSet<>(), Java internally instantiates a HashMap. But a HashMap requires two things: a Key and a Value. Since a Set only has elements, Java performs a clever "hack": The Key: Your element (e.g., "Apple") becomes the Key in the internal Map. The Value: Since the Map must have a value to function, Java uses a single, private, static Object called PRESENT. Every single entry in your HashSet points to this same dummy object in memory. 🚀 Why build it this way? Why didn't the Java creators write a separate algorithm for HashSet? It all comes down to the DRY (Don't Repeat Yourself) principle: Instant Uniqueness: A HashMap is already designed to prevent duplicate keys. By putting your elements in the "Key" slot, the HashSet gets duplicate prevention for free! Blazing Speed: The HashMap is highly optimized for performance. By reusing it, the HashSet automatically inherits O(1) time complexity for adding, removing, and searching. Consistency: Both structures rely on the hashCode() and equals() contract. Using the same underlying logic ensures that your objects behave consistently whether they are in a Map or a Set.

#day22 today understand all object class in java with hashcode,clone,toString(),equals,getClass(),getName(), instanceof, Objects with CloneNotSupportedException in deep dive Thanks Rohit & Aditya Bhaiya🙏🏻 @CoderArmy @rohit_negi9 @adityatandon02 @java