Tagir Valeev

I like how @briangoetz.bsky.social uses type nullability markers ? and ! in an unrelated discussion without even explaining them, like if it's already well-known thing that exists in the language for a long time 🙂

/* * Package private constructor. Trailing Void argument is there for * disambiguating it against other (public) constructors. */ String(AbstractStringBuilder asb, Void sig)

As named constructors are not possible in #Java, some non-public constructors in OpenJDK contain bogus parameter, just to differentiate them from other constructors.

“Sudo, Make Me a Sandwich! – Live Coding With Agentic AI in IntelliJ IDEA” by @antonarhipov.bsky.social is now live: youtu.be/1cx8vDJYi74
Watch Junie, JetBrains’ coding agent, in action and see how far AI can go in dev workflows.
#IntelliJIDEAConf

I hope you'll enjoy it! Though a professional like you likely knows already more than half of the things I'm writing about :-)

I've wanted to buy "100 Java Mistakes..." by @tagir-valeev.bsky.social for a while. Done 👍. Tagir knows so much about Java, and I'm sure I've made many of these mistakes. I'm looking forward to reading this now. 🙏

Using AI slows down experienced developers?
metr.org/blog/2025-07...

The nice thing is that it fixed (and fixed correctly) the real bug in the test, despite I said in the prompt that the test is correct and you need only to write an implementation.

Asked JetBrains Junie to implement Stream.takeWhile support in our dataflow analysis. It implemented it, and the tests I wrote beforehand are passed. However, it just reused the Stream.filter implementation. Apparently, I needed better tests. Still, it's a good start, not complete garbage.

If you have a CPU-intensive computation which moves/copies data between HashSets a lot, it may make sense to enumerate all your objects (map them to consecutive integers) and move to BitSets instead, mapping back at the end. They are waaaay faster.

I'm going to visit JVM LS this year! See ya there!

One of my top 3 highlights this year thus far was being invited by the @jetbrains.com @intellijidea.com team to celebrate #30YearsOfJava. The #Java story is rooted in both ongoing technical innovation & community participation.

My thanks to @maritvandijk.bsky.social who made this all possible.

IntelliJ IDEA Conf 2025 | June 3-4, 2025 We invite you to join us for IntelliJ IDEA Conf 2025 and gain insights from industry leaders and experts.

#Java peers...the 2025 @intellijidea.com Conference is around the corner (June 3-4)! There's still time to register for this FREE virtual event: jb.gg/c463w8

Hear from host @maritvandijk.bsky.social and me as we kick things off to celebrate 30 YEARS OF JAVA!

TIL: In #Java format strings, you can specify indentation to a single percent character.

YouTube video by IntelliJ IDEA, a JetBrains IDE 30 Years of Java

Kinda cool #Java30Years #JetBrains www.youtube.com/watch?v=kHyb...

Here's how the analytics for a single flaky test looks like inside the IntelliJ project.

Schokolade der DB auf dem Buch '100 Java Mistakes and How to Avoid Them' von Tagir Valeev auf dem ICE Tisch.

Manchmal sind es die kleinen Dinge, die einem das Leben versüßen oder auch 100.
@bahn.de @tagir-valeev.bsky.social

🤗 Mellum is now open source on @hf.co!

It’s a focal model that is small, efficient, and made for one thing: code completion.

⚙️ Trained from scratch by JetBrains.
🌱 First in a growing family of dev-focused LLMs.

🔗 jb.gg/hi_mellum

And it prints 'From var'. However, you can remove the variable declaration, and it will resolve to a class and print 'From class'. There's no ambiguity, as an instance-bound method reference has a priority over a statically bound one.

You can try something simpler, e.g.

void main() {
class C {
static void run() {
System.out.println("From class");
}
}
Runnable C = () -> System.out.println("From var");

Runnable r = C::run;

r​.run();
}

IDE resolves C properly to a variable.

One of the few places where both class name and variable name can appear is the method reference qualifier. In this case, first it's assumed to be an expression (variable reference), and if it doesn't work, then there's an attempt to resolve a class. If the variable works, we don't try a class.

The correct answer is counter-intuitively, Outer2​.foo. Normally, classes and variables have separate namespaces in Java, so importing class and importing variable (static field) with the same name does not produce an ambiguous import.

Crowdsourcing compiler fuzzy-testing.

Ok, here's my solution. Full of warnings, of course, but who cares about warnings?

void main() {
O<O<O>> O = O<O>::<O>O;
}

interface O<T> {
void use(O c);

default <C> void O() {
}
}

Not sure. You'll get extra points for such a solution :-D

Not necessarily. It works either way.

Btw ChatGPT 4o cannot solve it for me (using the post above as the prompt). You have a chance to be smarter than AI :-)

Provide the declaration of the O type, so this statement could be a valid #Java statement:

O<O<O>> O = O<O>::<O>O;

Well, I didn't fall for Mistake #11 from @tagir-valeev.bsky.social's book, but quite something similar:
Jackson Objects are both mutable AND return the updated self. I took it for being a copy-then-modify-Operation and used the original value elsewhere - which was modified, too. 😬

#java #mistakes

What is the output of the following Java code?
A: Outer.Inner​.foo
B: Outer2​.foo
C: Compilation error
D: Runtime exception
(No idea if it's possible to post a poll here)

Two lines of code eat too much of time in a user-supplied CPU profile. These lines exist for ages. It's not so clear why they were added. Let's just remove them🤞