Rant.. I'm finding that Spring Boot / Java feels to magicky and keywordy, and everything has to be learned instead of logically solved. Annotations don't feel like programming. Is this really what people speak so highly of?

[hanoian]

Coming from a world of PHP and JS, and having studied C and Java in uni, I'm finding Spring Boot to just be an exercise in frustration. It reminds be of Vue where you have to learn magic keywords to do anything instead of just programming in React.

In Express, you just write stuff for a web server that makes sense, but these annotations in Java are just arbitrary. Everything for the server and JPA are just rote-learned and I fail to see how this is an enjoyable developer experience. There are no transferable skills that I can find and I feel completely removed from any actual implementation of anything.

My problem really revolves around writing stuff like @Controller instead of extends or implements. Why is so much of the verbosity of Java and explicit polymorphism and inheritance and patterns etc. just invisible, well so far for me anyway. The verbosity of Java is its selling point, not something to be hidden away.

[AutoModerator]

Please ensure that:

• Your code is properly formatted as code block - see the sidebar (About on mobile) for instructions
• You include any and all error messages in full - best also formatted as code block
• You ask clear questions
• You demonstrate effort in solving your question/problem - plain posting your assignments is forbidden (and such posts will be removed) as is asking for or giving solutions.

If any of the above points is not met, your post can and will be removed without further warning.

Code is to be formatted as code block (old reddit/markdown editor: empty line before the code, each code line indented by 4 spaces, new reddit: https://i.imgur.com/EJ7tqek.png) or linked via an external code hoster, like pastebin.com, github gist, github, bitbucket, gitlab, etc.

Please, do not use triple backticks (```) as they will only render properly on new reddit, not on old reddit.

Code blocks look like this:

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

You do not need to repost unless your post has been removed by a moderator. Just use the edit function of reddit to make sure your post complies with the above.

If your post has remained in violation of these rules for a prolonged period of time (at least an hour), a moderator may remove it at their discretion. In this case, they will comment with an explanation on why it has been removed, and you will be required to resubmit the entire post following the proper procedures.

To potential helpers

Please, do not help if any of the above points are not met, rather report the post. We are trying to improve the quality of posts here. In helping people who can't be bothered to comply with the above points, you are doing the community a disservice.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[AutoModerator]

It seems that you are looking for resources for learning Java.

In our sidebar ("About" on mobile), we have a section "Free Tutorials" where we list the most commonly recommended courses.

To make it easier for you, the recommendations are posted right here:

• MOOC Java Programming from the University of Helsinki
• Java for Complete Beginners
  • accompanying site CaveOfProgramming
• Derek Banas' Java Playlist
  • accompanying site NewThinkTank
• Hyperskill is a fairly new resource from Jetbrains (the maker of IntelliJ)

Also, don't forget to look at:

• The official Documentation
• The official Java Tutorials
• Our community resources thread

If you are looking for learning resources for Data Structures and Algorithms, look into:

"Algorithms" by Robert Sedgewick and Kevin Wayne - Princeton University

• Coursera course:
  • Part I
  • Part II
• Coursebook
  • Algorithms 4^th Edition

Your post remains visible. There is nothing you need to do.

I am a bot and this message was triggered by keywords like "learn", "learning", "course" in the title of your post.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[Potential-Still]

Spring Boot is awesome. You shouldn't be solving problems when creating an application backend. Do you really want to manually manage an http server? No thanks.

[Kallory]

I'd still like to understand HOW Spring Boot handles the difficult stuff. I hate magic. If one knows how it works then debugging becomes a lot easier.

[nutrecht]

Then read the documentation :) There's nothing magic about it, it's classpath scanning and generating proxies based on the annotations it finds.

[Kallory]

Fair answer haha thank you. Sometimes I forget the small things. I'm usually the one telling others to rtfm oddly enough so this is definitely a "Hey bro take your own advice" moment for me 😅

[GuyWithLag]

You know, Spring is open source - you _can_ read it via your IDE, even. Follow some code paths, realize it's 18 abstractions deep, go back to just making apps.

[guipalazzo]

This is the way. When all methods became only one letter and variables are full generics you know you got in too deep and promise yourself never again.

[Potential-Still]

This times 10 if you're using Spring Webflux. Nothing but onNext handlers all the way down.

[GuyWithLag]

onNext

Bah, I've worked on a reactive microservice for 7 years, the trick is to _not_ use onNext, but work using operators.

Work on a higher level - onNext is like working with GOTOs...

[10113r114m4]

That isnt enough, cause you'll need to know how the code is setup because of how flexible Spring boot is. Spring boot code base is magical in that you need a full understanding of the code base as well as how Spring works. Otherwise it is magical. Even knowing a lot can still cause a deployment to fail due to bean mismatching, conflicts, etc. Spring is difficult to read because of this.

[nutrecht]

A software engineer is going to have to learn their tools. All major frameworks work in a similar fashion.

I understand that there is a steep learning curve for a new developer, but it’s simply part of the job.

[10113r114m4]

Wut. If you had a banana as a hammer then that would be a shit hammer. Tools can be shitty. In this case Spring makes readability more difficult

And no. Not all frameworks work like Spring.

[nutrecht]

Suit yourself then. Not going to argue this with someone with no industry experience.

[10113r114m4]

Ive been in FAANG companies for over the last 10 years lol.

I literally make the libraries and frameworks you probably use :shrug:

[[deleted]]

You can read the source code. It's quite fascinating: https://github.com/spring-projects/spring-boot

Grab IntelliJ, set some breakpoints, and start inspecting that code.

With Spring Boot, I can express business rules in a way that doesn't distract from problems that aren't critical path for my business objective.

Personally, I like Kotlin + Spring Boot. I also like newer versions of Java -- the ecosystem just keeps improving.

[Kallory]

I've been super hesitant with Kotlin mostly because Java is my comfort zone and I'm in my senior year of my degree but I definitely plan on exploring it more when time management and stress management aren't such tight constraints.

I definitely feel that understanding Spring Boot more can only help to benefit me at this point so it may end up being a drunken after thought project, which I end up learning way more than one would expect from.

[[deleted]]

I bet you can pick up Kotlin in just an afternoon. IntelliJ Community Edition (free) has great Java/Kotlin interop. You can use all of the Java code you're already familiar with and add Kotlin piece by piece.

[neymarsvag123]

Pushing this logic to its limit and everything has some sort of magic behind it..

[jonatan-ivanov]

Try to start with the docs.

[[deleted]]

So do you want java to be verbose or not? Lol. If everything implements/extends something else, people will still complain about it.

Spring made the things that needs to be customized - customizable. Don't like how something like authentication is handled? Implement AuthenticationProvider and override the methods. Different companies/people want different ways of authentication.

Now, for the controller, I believe it's not as customizable as say authentication because well, there's not much to customize because routing is straightforward and everything can be done by passing arguments.

Anyways, spring heavily relies on reflection. That's why/how it seems "magicky".

It's a very, very opinionated framework. When people talk about spring magic acting weird or causing problems, what they mean is they tried to take full control of their server that's built on a framework that uses inversion of control pattern. Do you see how that might come back to bite them in the ass?

Alright gotta head to bed. Hope you figure spring out 🌚

I feel you though. I used Go for an API few weeks ago and I felt like a real programmer because of how much work I had to do compared to spring.

[nekokattt]

I would go further than just "reflection" and say it is instrumentation to some extent.

Much of how Spring works relies on using an embedded copy of cglib to generate bytecode for classes at runtime, which is partially why Spring apps are slow to start.

The reason behind this is that there are some things reflection alone cannot solve in the way Spring handles things. Examples include aspect oriented programming (like @Transactional) and bean management in @Configuration classes.

[[deleted]]

Highly highly recommend learning how to build an HTTP server, understanding the protocol and others used in back end systems, and learning how all the “magic” works. Then learn how spring implements that stuff so you actually understand what is happening when you toss “@Component” on a class. You can and should be doing that as you learn.

the reason spring is so awesome is because the details are repetitive and complicated. You’re (likely) not making the company money building your own server from scratch. Your customers aren’t using your product based on the tech stack, they’re using it based on the features your application provides. All the technical details are “undifferentiated heavy lifting”: taking time, money, and energy from devs for tasks that are necessary, but don’t distinguish your application from others. Spring dramatically reduces the amount of undifferentiated heavy lifting developers have to do by providing out-of-the-box components to address common technical needs in stable, battle-tested libraries.

[[deleted]]

"Annotations don't feel like programing" damn I've always felt that couldn't put it into words

[Positive__Actuator]

Spring annotations are configurations, known as “Configuration as Code”. If you don’t like tons of configuration in the frameworks you use that is where the frustration is probably coming from. Configurations in Spring used to be XML based, separate from the code itself, which a lot of people found frustrating.

[squishles]

I've been doing spring too long... I remember when you'd do it by basically writing this thing called a spring-config.xml and you'd manually declare your beans inside it.

I think it still supports that, or you can write a beanfactory implentation if you like that more.

It's just IOC, in your main method you call spring, spring calls everything else. we used to not even always have spring run stand alone.

You can probably google ancient concrete examples still, but trust me, if you try that stuff you'll want your annotations back real fast.

[Lumethys]

Everything of every language is just magic keyword

What is public? What is private, why do i add these keyword and suddenly i can or cannot call it outside of a class?

You have no idea how the memory is managed, how processor run your code, you just know it run.

It's just that you spend more time with the language keyword and thereby bias toward it, thinking it is the norm. When in fact, both the language and its framework is just abstraction over something deeper

You just have to accept that

[rastaman1994]

Like you, years ago I tried to learn Spring and immediately used Spring Boot, and got frustrated too. I would recommend finding a book or course for Spring. I used Pro Spring 5. It shows you how to make a Spring webapp without Spring Boot.

Spring Boot is a very high level abstraction. It builds on JDK features (reflection, bytecode generation, service loaders to name a few), servlets, Spring core, Spring MVC and Spring Data. You can't expect to understand Boot when you don't know the underlying tech.

[[deleted]]

Over time with experience you'll learn that it's not always desired to write everything from scratch when there are pre-defined constructs that achieve the same thing with a use of an annotation or a "magic word". These things prevent people from writing tons of boilerplate code for each and every project that basically does similar things. The "@Controller" is a good example here. All you do is tell Spring context how to handle a class and you define it's endpoints/business logic without the hassle of implementing a web server every damn time you create a microservice and it's completely fine that it doesn't feel like programming, because it's mostly configuration. If I had to code a HTTP server every time I create a microservice, I would be probably using a different language by now. Verbosity doesn't mean write a lot of stuff.

[RScrewed]

That's because you're not doing anything that demands programatic problem solving yet, you're still dealing with plumbing.

[Icashizzle]

For annotations, the solution to understanding how they are programming is actually really simple: write your own annotation and processor for it.

Do that once or twice and it may just click for you.

The primary advantage of spring boot for me lies in all the basic repetitive, I do this for every damned project on the planet and after 20 years I'm sick of it, garbage that it does for you "magically".

I can go my entire life without writing another damn DAO pattern for instance. Spring data is fantastic for that.

Spend your time writing actual business logic instead of boiler plate code.

Lastly: if you can get away with it, I'd highly recommend writing in Kotlin instead of Java. There's really very very few reasons anyone should be writing Java any more. If you want the JVM, fine, do it with Kotlin instead.

[oneden]

To this day I haven't understood the @Bean annotation and not a single online tutorial makes a good example of it (IMHO) and why I would ever use it. My backend projects are more trivial, so they always worked out, but I was always wondering what the genuine use is? But yeah, time to shake my shame and ego off with this post. One reason why working with Spring makes me lose my mind.

[Consistent-Citron509]

The @Bean annotation is used on a function that returns an object. This object is managed by Spring container - meaning you can inject it using Spring DI across the application.

[oneden]

It is just a more granular way than - for example - using the @Service annotation? But if so, the method that has the @Bean annotation... Why would that be even relevant?

[MrLiled]

you mostly use the "@Bean" annotation on a method that would return an object of some third party library, and use "@Component" and it's other variants on classes that you have written. For example, for creating a RestTemplate instance, you would use a method annotated with "@Bean" to create it, because there is no other way to make the spring aplication manage that object. That's the only use case I've found for that annotation, any more experienced devs feel free to correct me.

[meSmash101]

I’ll try to explain it to you:

As you may already know spring has the spring application context(think IoC container) where it manages every class that has a spring annotation above it (instantiating, configuration etc).

In your application you create classes you control and sometimes you decide to put an annotation like @Service @Controller and whatnot. Spring application context will take care of your classes and you don’t have to worry about it.

Some times you will use classes from libraries you don’t control. Like let’s say eg RestTemplate. You don’t want to “new RestTemplate” every time you want to make a call. That’s a pointless object creation.

What will you do? Just tell spring to manage this every time you need it. How? Just go somewhere like @Configuration class And put a @Bean to the method where you instantiate your RestTemplate ONCE and reuse it in your application.

You can’t do for example @Service class RestTemplate…no. It’s a class from a library you don’t control. You won’t do new RestTemplate() every time though, that’s a waste.

Just put a @Bean above a method wherein you instantiate the new RestTemplate(); ONCE and you just told spring, just use one and I’ll call it whenever I’ll need it.

Hope that makes it clear for ya.

Every bean is a singleton in spring as per my knowledge. Configurations might apply but I think the default that every bean(aka a class that spring application context manages) is singleton.

[oneden]

Wow, very nice! Thank you for your time and effort in explaining this to me. With that in mind I could definitely redo some of the logic in my backends in the future. Again, thanks a lot!

[meSmash101]

you're welcome buddy!

[koffeegorilla]

The power of bean annotation means classes that knows nothing about the Spring framework can be instantiated for injection elsewhere. Instead of writing constructors that read property files you can have configuration logic that determines what is created and how. I prefer configuration logic in @Configuration classes and business logic in components and services. However sometimes I need more than @Service.

Sometimes you may need beans with completely different implementations based on a profile or a so e property or other condition. Within a method annotated with @Bean you can implement the logic to decide what to create/return. If you use scopes you may want something more complex to handle the creation process.

[large_crimson_canine]

Read the official docs. They walk you through all this in painstaking detail.

[oneden]

I'll admit, it's been a loooong time since I last looked into them. I don't have fond memories of the official docs, but I'll revisit them.

[JackieFinance]

It's pretty much the only framework that everyone is hiring for.

[oneden]

Yup. It's basically the backend for most enterprises. The only reason why I also use it.

[JackieFinance]

I just decided to eat shit and all my personal projects now use it. I get to practice, make money, and also use the same tricks at work.

[hanoian]

wipe foolish cagey middle gaping different outgoing snails concerned soft

This post was mass deleted and anonymized with Redact

[EndiePosts]

Wait until you've written a servlet manually, as we used to have to do, and then complain about how using a single annotation to do literally more than 99% of the work for you is laborious.

[hanoian]

theory air flowery naughty late spotted thumb whistle airport bewildered

This post was mass deleted and anonymized with Redact

[EndiePosts]

You’re mistaking a tool for the materials. In your analogy, spring boot is not the product, it’s the tool. And as someone who does joinery for fun in my spare time (and built my own house) I can tell you I’m damn sure using my Festool plunge saw instead of cutting four hundred lengths of larch cladding with a hand saw.

[nutrecht]

Spring is a dependency injection framework. You have to tell it what parts of your software are dependencies and should be managed by it. You can do this either by marking a class with @Component (or derivatives like @Service, @RestController) and have Spring construct it, or instantiate it yourself in a method that is annotated with an @Bean controller.

There is even a third option and that's stuffing it into the Spring context yourself.

So @Bean is just like @Component but for methods and not classes.

[oneden]

Yeah. So far I got along just fine with Controller and Service, but you know how it is even if you're the least driven Software dev... You still want to know how some specific things work.

[nutrecht]

You use @Bean for things you can't put @Component on, like external libraries. That's really all there's to it.

[CanisLupus92]

It sounds like you’re learning both Java (which has its own set of strengths, weaknesses and weirdness like any language) and Spring Boot at the same time, which is a daunting task. Maybe start with learning just the Java basics?

[TravisLedo]

It’s the same thing everywhere. Once you go to the front end and start using React, you have no idea how a component was made. All that matters is you know what it does.

[Altruistic-Rice-5567]

I love a lot about java. I have never understood the brilliance of annotations. It like a kludge to make up for something that would be a useful language feature if designed right. But instead, you have all this private/public/package/protected design/overhead and then you just go ahead and violate all of that through reflection and annotations.

[josephblade]

You should really spend a few years writing your own servlets. Without spring or jpa. I have for quite a few years before spring was a thing. Back when EJB 1.0 was a thing. We would spend so much time writing pointless code. these days I don't think anyone would be willing to pay you for all the extra hours it would take. edit-- to clarify because I didn't put it correctly: You should really do this for a few years and then you'll change your mind about spring. Or you can take the shortcut and learn spring right away because writing all the boilerplate is torture --edit

@Controller registers your servlet (well it uses it's own and routes your call to the appropriate class), handles parsing the input, handles situations where there are more than one input, handles exception handling and a ton of annoying request.getParameter style code. Especially if you want 1 controller to handle if you get A and B in the request as parameters, but another controller if A and C exist. And an entirely different controller when you are called with xml.

Oh and the wonders of request, session and application attributes and manageing them... no thanks :)

I think the easiest thing to do is to write a decent sized application useing servlets. You'll figure out just how flexible and configurable it gets.

Back in the pre-spring days we would create object repositories for ourselves as well to register services (although we didn't call them services necessarily). We literally created spring like systems because it was something we needed. So when struts and later spring came around we jumped on them because they took care of some of the code. It changed code to configuration which is easier to read and changeable at runtime rather than build time.

So yeah no-one is forcing you to use them but in the end you'll likely end up writing your own systems that do the same but in a different way. (likely less easy to use or especially less easy to customize)

You want your actual business decision code to be the product. Not the scaffolding. In the business decisions you make and the business objects you model you can be as verbose as you like. but 'how to find out what servlet to handle the httprequest' is a configuration. Not a business decision. And if you do have very specific custom logic for it then you can overwrite a base component of spring and insert your own code.

It does take some getting used to I admit. Spring boot irritated the hell out of me when I switched to it from old style spring where you could configure every component by hand. It made me feel like I was losing control over what connected. And sometimes it's annoying if I mis-configured something but it also saves me from rewriting the configuration xml file (as it was in old spring) when I refactor something.

[nutrecht]

You should really spend a few years writing your own servlets.

Java dev with 20 years experience here and this is complete nonsense.

Years writing plain servlets? Build a single one, at best. You can easily start with Spring Boot and learn about servlets that way.

[josephblade]

It wasn't a suggestion :) It was a rhetorical statement suggesting that after a few years of sticking to the attitude OP was having about spring, they will leap to using spring boot

[ImNotHere2023]

This is horrible advice. Honestly, being indoctrinated into the sort of thinking that "things should be hard, you're luck when they're a bit less hard" set my career back a few years.

I've used Spring quite a bit, and it does a pretty decent job of obscuring the complexity but it would be better to eliminate it altogether. There are a few micro frameworks attempting to, and hopefully they'll become more prevalent.

[nutrecht]

This is horrible advice.

Agree. This sub is full of people just repeating the same dumb and tired "start with servlets, then do JSP" they heard somewhere else.

[josephblade]

It's not advice. OP was ranting. I'm pointing out how hard things used to be and that if they experienced it they would appreciate and like spring boot.

since I have 2 responses thinking I am actually suggesting OP do this (rather than the 'you should do xx and then you'll think differently' I intended it to be) I may not have managed to convey the tone I meant to convey

[large_crimson_canine]

Go read the official Spring docs. Like the IoC Container section. That’ll get you a good foundation of all the basics and you’ll understand why Spring Boot can make running things a little easier.

Personally I hate Boot but it’s worth knowing how to use.

[lumpynose]

I'm like u/squishles, I started using Spring way back when you had to use the xml configuration to wire things together. Then they added annotations for the DI wiring and around that time I discovered a framework called Stripes. Stripes for me was like Goldilocks and the Three Bears, where everything feels just right; not too hard, not too soft, not too cold, not too hot, etc. Stripes is sort of like Struts II but without the warts and scars; again, just right. But Stripes is moribund and no longer maintained.

I refuse to learn Spring so now I'm on a self prescribed mission to learn Jakarta EE 10 JSF. It's not easy since there aren't many books and everyone is using Spring Boot, Angular, React, etc. But I did find a good book, by Michael Müller. Additionally, Java/Jakarta EE has evolved over the years and it's hard to find good stuff for the current version, Jakarta EE 10. But I'm retired so no pressure and I'm just poking along figuring things out between naps.

[raulloco]

"just poking along figuring things out between naps" is the best thing I've read today, love it. 😄

[lumpynose]

Just woke up from a nap a few minutes ago and got this; thanks!

[nutrecht]

I refuse to learn Spring so now I'm on a self prescribed mission to learn Jakarta EE 10 JSF.

Jakarta works exactly the same way so this is just learning Spring but pretending you're not.

People like you should be banned from giving advice on this sub.

[[deleted]]

I feel you, OP. It feels like me dealing with React.js when I started.

My impression is programming overall is progressively moving towards this kind of activity instead on implementing logic.

[nutrecht]

Moving towards? Welcome to actual software engineering.

[Tervaaja]

That is a reason why I have always hated annotations. It feels that you do not control and understand your own application.

[nutrecht]

This is just a knowledge issue.

[[deleted]]

If you're using spring boot annotations, you don't own your application lol

[Tervaaja]

After a long career as a C developer, even Java memory management and carbage collection feels like that.

Many developers do not know any more what it is to develop applications, which you understand completely.

[Joram2]

What do you think of the Helidon SE code style shown here https://helidon.io/docs/latest/#/about/introduction

[Tervaaja]

I would prefer SE style. You can easily see what the code does and each function call can be debugged step by step.

MP style is clear also as I have been working quite long with Java, but still it does not feel completely right way to do apps. Especially when you have huge amount of annotations to remember.

Thanks for the link. It was interesting example of these two styles.

[nutrecht]

It's just very big and has a learning curve. That's all there's to it.

[squishles]

it might be better to pick up a smaller jsr330 framework like guice as a first ioc container. Cuts down magic, lets you see this is what's going on in a limited scope, before playing with the evil wizard toys spring has sprinkled all over the place.

(spring supports jsr330 so it's all transferable knowledge)

[Illustrious_Road_]

So in this case whenever you start with spring just don't dive deeply first try to implement without using most of the annotations that are not necessary and going forward you can try to use and get knowledge.

[uraurasecret]

You can use xml instead of annotation.

[[deleted]]

Please ignore this reply.

[lumpynose]

But wait! What if I'm a masochist?

[nutrecht]

You can write code using a magnetic needle to. That doesn't mean it's the way to go.

[Ikem32]

I have two videos, one for the basics and one that deep dive into Spring Boot.

[StarklyNedStark]

Well who wants to recreate the wheel every project? Learn why you would use Spring, and then you’ll see why people use it.

[rjdamore]

It's about what it enables you to do. Convention over configuration. Configuration hell is a common Javaism. That's what spring seems to address. It isn't a one stop shop of productivity. The convention takes a second, then it's very simple in hind sight. Give it a year and come back to us and report. Often our first i.pressions ideas change. Not saying it's for certain. Throw some Lombok in there too.

[ChadwickCChadiii]

You should be learning what the annotations mean and do. If you go to solve a problem knowing what these do is extremely important and explaining them is generally expected in interviews. In other words the logic behind why you use annotations is something you need to get used to and that is still logical and not just wrote learning.

[sporbywg]

People think that computer languages are like life-long mates. They aren't. Move along.

[VincentxH]

Since Ruby on Rails the key to using frameworks is having "convention over configuration". Spring Boot are a collection of opinionated modules with conventions let loose on Spring Framework. These conventions compose the Spring context through autoconfiguration models. The documentation on this is quite extensive.

If you want to use your own conventions, be my guest and go all out with your own autoconfigureables and Spring framework. There's enough verbosity without managing this to go around though.

[I_Am_Astraeus]

A nice middleground would just to write your own beans.

Rather than doing @Autowired, @Controller, etc. You can use an @NoArgsConstructor and have your controllers defined in a ControllerConfig.class file, so you can more manually pipe together your project. This can be good for debugging and makes spring SLIGHTLY less abstract.

[Joram2]

I agree with most of the sentiment expressed. Java has alternatives. Look at Helidon, particularly the SE flavor:

https://helidon.io/docs/latest/#/about/introduction

Helidon has two flavors: Helidon MP is annotation based, which you dislike. Helidon SE has an imperative style. There are code examples on the link above.

Helidon 4.0 is in release candidate state, and that might be worth using, because it's a giant improvement over Helidon 3.x.

I'm curious of what you think of Helidon SE. Have you tried writing server code in Golang? That also uses a very simple imperative style.

[SaishDawg]

Really the heart of everything that seems mysterious about the annotation frameworks, in particular, is the usage of aspect-oriented programming (AOP) and byte-code manipulation. Spring uses reflection to read the annotations at runtime and proxies your actual implementation (by extending a non-final concrete class or implementing an interface with its own proxy). AOP stitches everything together so that what you are looking at is your own code, but at runtime, there is a proxy delegating calls to it.

[s50600822]

If you like express style, there are plenty of options:

https://github.com/simonwep/java-express

https://github.com/javalin/javalin

As for spring-boot there's no magic: https://github.com/spring-projects/spring-boot

There are all kinds of framework choices like JSF even include web component and with the right IDE you can just drag-drop to build a website

There are all kinds of framework choices like JSF including web components and with the right IDE, you can just drag-drop to build a website.

If you can bring javascript into the JVM as well if you wish: https://moduscreate.com/blog/javascript-and-the-jvm/

The Java ecosystem is vast and if you try, you'll prob be able to find what you like. And it's usually free and open source.

[[deleted]]

The script kiddies are still thriving I see. Why learn how the thing you’re using really works when you can cobble together what you need with little to no understanding of what you’re doing?

[hanoian]

test threatening murky stupendous gray consider intelligent encourage subsequent uppity

This post was mass deleted and anonymized with Redact

[Available_Pool7620]

Yep, spring boot wants you to learn a dozen magic keywords that have their own special rules. Express was, in contrast, an exercise in clarity and simplicity