<!DOCTYPE html><html><head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body>
<font size="4" face="monospace">Thanks for starting this
discussion. Indeed, I think it is good to have a fresh look at an
empty IDE window, and see where we think it should go.<br>
<br>
First, I think the "but everyone knows public static void main, so
we should keep it that way forever" argument is a bit silly. We
should guide people towards the best version of the language; many
developers learn a lot about Java from the hints provided by the
IDE.<br>
<br>
Let's skip over the "what should the defaults be" for a second,
and talk about refactoring between the various versions. IDEA
already has hints for when `public` is unnecessary, such as the
public modifier on instance methods. It renders `public` in a
lighter tone and offers a quick-fix to drop it. It seems
reasonable to do the same with `public` on main? Similarly, if
the class already has a no-arg constructor (or perhaps has _no_
explicit constructor, or an empty no-arg constructor), it can do
the same with `static`, offering to vanish it for the user. And
with `String[] args`, if `args` is not used in the body, it can do
the same with those. <br>
<br>
So separate from the question of defaults, a class with p-s-v-m
that doesn't need public, static, or args, the IDE can guide us to
a more minimal version of main. That seems nice. Similarly, for
an instance main, or a main without args, I assume there will be
quickfixes offered to add back `args` or `static`, in case the
minimal main is not what the user wants. With all this in place,
even if the default is wrong, it is easy to incrementally navigate
up and down to the "smaller" or "bigger" declaration as desired.
<br>
<br>
I think your starting position of "no public" and "no args" is
good. I like your story about "guessing" whether the user wants
an `args` variable; another possible heuristic, besides going
strictly by name, is whether they use an undeclared array variable
(such as on the RHS of foreach, or x.length, or x[i]), and offer a
"was that supposed to be the arguments?" quickfix. <br>
<br>
Also, since there can now be multiple possible main candidates, I
think another thing the IDE can help with is identifying when a
method called `main` is _not_ the main method that the launcher
will invoke. (The "real" main method may be in a superclass
now.) <br>
<br>
Static is the hard one. "Instance main" is the least well known
aspect of this JEP; it is hard to tell whether the community will
adopt it as their default (I suspect some will, some won't, and
there will be low-grade style wars about it.) <br>
<br>
<blockquote type="cite">
<div>We cannot generate `void main(){}` inside the class that
contains no default constructor, as this method will be
non-functional and users might be surprised and confused. </div>
</blockquote>
<br>
By "default constructor", you mean no-arg, right? Because if you
have _no_ explicit constructor, you get a free no-arg constructor,
and are fine. <br>
<br>
<blockquote type="cite">
<div>I lean toward generating 'static' by default for explicit
classes (regardless of its constructors) and no 'static' for
implicit classes. However, I'm not sure that it's the best
solution.</div>
</blockquote>
<br>
I think that's an OK starting point, but I might suggest to nudge
you over into dropping the static if the class is sufficiently
"empty" (no ctors, empty no-arg ctor, etc.) I think there might
be momentary confusion about "where's my static", but if so,
that's a one-time learning opportunity, and thereafter it will be
fine.<br>
<br>
As to `psvm`, my first thought is to keep psvm as is, for people
who are used to it, but then the psvm declaration will immediately
have dimmed out `public`, `static`, and `String[] args`, so users
will see these are optional and may take the quickfixes to drop
them. And then have another macro for `main` (which is easier to
remember anyway) that is the "smart main wizard" that declares the
main method using the minimal set of gunk relative to context,
being sensitive to the presence of an explicit class declaration
or not, explicit ctors or not, etc. But I can also see how it is
nice to just guide people to the new Java with the old name. So I
think either way works here. <br>
<br>
Stepping back a step, I always get a new class window with ctrl-N,
which asks me for a class name and fills in `public class Foo` for
me. Will the "new class" dialog have an option for "implicit
class"? (And, what do we call it? The spec term "implicit class"
will not necessarily be helpful to the target audience, since they
may not know that's what they want. Perhaps some sort of "new
single file program" option?)<br>
<br>
<br>
<br>
<br>
<br>
</font><br>
<div class="moz-cite-prefix">On 5/8/2025 4:32 AM, Tagir Valeev
wrote:<br>
</div>
<blockquote type="cite" cite="mid:CAE+3fjZot-=cuyEH1bM0sHGvYDiaw6-iXL56DacoSk9UR_SFLg@mail.gmail.com">
<div dir="ltr">Hello, dear experts!<br>
<div><br>
</div>
<div>This discussion is not exactly about Java specification,
but I think we have the right people here for this topic.</div>
<div><br>
</div>
<div>The Java IDEs usually provide a way to automatically
generate a main method using some kind of template named
'main' or 'psvm' (which is short for 'public static void
main'). Historically, invoking such a template generated a
code like this:</div>
<div><br>
</div>
<div>public static void main(String[] args) {</div>
<div> <caret is here></div>
<div>}</div>
<div><br>
</div>
<div>However, when 'Compact Source Files and Instance Main
Methods' feature (JEP 512) is available, this doesn't look
like a good default anymore. Some of our colleagues advocate
that keeping the old signature is good because this is what
people get used to, but I think we should reconsider this.</div>
<div><br>
</div>
<div>Now we have multiple ways to generate a main method:</div>
<div>- 'public' may be present or not</div>
<div>- 'static' may be present or not</div>
<div>- 'String[] args' may be present or not</div>
<div><br>
</div>
<div>So technically we have eight different variants. What would
the user expect by default?</div>
<div><br>
</div>
<div>In my opinion, 'public' is simple: we should just drop it,
as it doesn't add any value. This reduces the number of
options to four.</div>
<div><br>
</div>
<div>The 'static' modifier is more difficult. 'static void
main()' and 'void main()' have different semantics: the latter
involves automatic class instantiation, it makes the main()
method inheritable (so inheritors if any may become
launchable), and it requires a no-arg constructor. We cannot
generate `void main(){}` inside the class that contains no
default constructor, as this method will be non-functional and
users might be surprised and confused. We might consider
adding the `static` modifier only in classes without no-arg
constructor, but this might be inconsistent, as users might
not understand why sometimes `static` is generated and
sometimes is not. Another case is implicit classes where
`static` looks really alien, and we never have problems like
no-arg constructors or inheritors. So I lean toward generating
'static' by default for explicit classes (regardless of its
constructors) and no 'static' for implicit classes. However,
I'm not sure that it's the best solution.</div>
<div><br>
</div>
<div>Skipping 'String[] args' by default seems nice, but it will
worsen the experience of people who actually need the args, as
they will probably need to type more. We can assume that the
variable named 'args' is implicitly available inside the
method body, so the user may use it via autocompletion, and
upon the first use, it will be automatically added to the
method signature. This is possible but somewhat weird: users
should know in advance that something named 'args' can be
used, even if it's not explicitly available in the code.</div>
<div><br>
</div>
<div>We can also create several templates (something like
'maina' for main with arguments and 'mains' for static main),
but this also complicates things and increases the cognitive
load to the users. Also, different IDEs may solve this
differently, and this may add confusion for people who change
IDE sometimes.</div>
<div><br>
</div>
<div>I would be glad to hear your opinions. What would you
expect from your IDE when generating a main method in Java 25?</div>
<div><br>
</div>
<div>With best regards,</div>
<div>Tagir Valeev</div>
</div>
</blockquote>
<br>
</body>
</html>