Oh wow, that's an IDE I haven't heard about for a while! We used to use this in school for learning Java. If I recall correctly BlueJ used to generate some nifty class diagrams to understand how your code fits together. That's about the feature I remember though.
I'd argue the fact an IDE like BlueJ is needed suggests Java isn't an appropriate language for beginners though. And it seems in recent years schools have been preferring Python as a first language which I think is far more appropriate. My teacher used to argue Java is good for beginners because it's a strict OOP language and teaches good habits, but I question how true that is. For one, it falsely assumes OOP is a good approach for an application that asks you to enter your name then prints, "Hello [name]".
I learned on Java and I really feel like it slowed me down in some fundamentals of programming logic. Books were raving about garbage collection, JVM, "everything is an object"; I had no idea what any of that meant or why it would make Java "superior". Boilerplate like `public static void main(String[] args)` got me into the habit of ignoring things I didn't understand. The netbeans IDE was doing a lot of great quality-of-life stuff like handling imports for me and as a consequence I had a very poor understanding of how any of that worked. When you don't know how to write a for-loop yet things like accessor methods, pointers, or encapsulation are going to go way over your head.
My highschool "Intro to Programming" class teacher (she is a wonderful woman) would say out loud "string box args" to have us memorize the boiler plate. Needless to say, we never even got to loops in that class.
One of my heresy's is I think things like classpaths are an antipattern. In that determining the location of files and other resources should be a separate process. One that's explicit and debuggable.
Funny enough, that's exactly why the Clojure community created deps.edn [0].
- optional dependencies
- use JARs on disk, local projects that build JARs, or Maven Central
- pull in code from git repo via url and git hash or tag ("git dependencies")
- different variations for the above for different targets (run, test, integration-test, etc.)
The problem with selecting programming languages, application frameworks, or anything else based on their "Hello World" example is that before you know it, you find yourself writing something more complex than "Hello World".
Most Internet discussion forums are absolutely insufferable, because the population is disproportionately students who haven't gotten past that stage yet. Or junior professionals who find that their jobs are more messy and boring than they expected, and want to spend their hobby time dabbling in one-person side projects that never get past that stage.
Among this audience, in that space, sure... static type checks are "cumbersome", testability is "overkill", refactoring never happens, etc etc etc.
Selecting languages based on their "Hello, world" complexity _is_ a useful metric when selecting a first programming language for the classroom. Both C and Java are inappropriate for that task: C has bookkeeping that's too easy to get wrong; Java is full of "you'll learn it when you're older" magic incantations.
i can't remember who said it, but its been claimed java isn't even an oop: its more class oriented programming...
i.e your not really dealing with objects all the time like in smalltalk but just "blueprints" that are a far shadow of what things should be (if i remember the claim correctly)
And Object, in this case (big O), is the name of a class.
Not everything is an object, as someone said, there are also primitives.
There are many other "things" in Java that are not objects (operators, statements, etc.).
Kotlin does set some of this straight. Everything inherits (indirectly) from the Any class. And primitives do not exist in Kotlin (as in Ruby or Smalltalk).
> ...schools have been preferring Python as a first language which I think is far more appropriate. My teacher used to argue Java is good for beginners because it's a strict OOP language and teaches good habits, but I question how true that is. For one, it falsely assumes OOP is a good approach for an application that asks you to enter your name then prints, "Hello [name]".
BlueJ was part of the recommended curriculum for Std 8th and 9th (I think) in some Indian schools circa 2005. My school wasn't in the same system. I had to learn PASCAL for the time my friends in other school systems had BlueJ in their curriculum. I used to be lowkey jealous of them back then. lol
I remember being told to use BlueJ in a CS class back in college. I realize it's an IDE made for learning but when I booted it up I was profoundly confused. I think I spent the first class playing around with it and downloaded Eclipse when I actually had to work on assignments.
Last weekend a high school sophomore told me his class was using Java with BlueJ. He'd never heard the term "object-oriented," which I thought was interesting. He said the previous year his class had covered some Python. Using Java in high school didn't sound very motivating, but then, my earliest memories of doing programming in school involve the gym teacher instructing me to type mysterious stuff like "GOTO 40" until finally a bunch of flashing lines appeared on my monitor...so maybe I should be envious.
Wow, I also had to use blueJ when I had to program in Java. It felt really weird to me as there as so many better alternatives. Any chance this was at the Erasmus University?
I had the same experience, TU Dortmund in 2007, algorithms 101.
I always figured the tool was deliberately chosen because it gave just enough support to the learner (syntax highlighting and class diagrams) but didn't offer any other safety nets or convenience. Kind of just one step away from programming in notepad.exe :)
> I believe faculty at Kent (UK) had some kind of hand in building it too.
That's correct! Michael Kölling, one of the original authors, was a lecturer who wrote it originally. All of OOP classes were taught with BlueJ, but we were allowed to other editors, though not many did.
>>>My teacher used to argue Java is good for beginners because it's a strict OOP language and teaches good habits, but I question how true that is<<<
Why wouldn't a teacher start off teaching the basics of programming with Python and then move to OOP with Python which wupports an OOP style? It may be a little frowned upon, but I mix up my styles depending on what's called for all the time. It's great and feels so naughty coming from someone who started out learning Basic then Java as my first "serious" language =)
The AP Exam covers Java and you have less than 180 days to cover everything from "what is a variable" to inheritance, recursion, and sorting algorithms.
My school has gone back and forth with starting with Python or Java in the Pre-AP course. There are pros and cons for both options, but ultimately a language is just a language. The concepts are what is really being taught.
The difference between a math variable and a computer variable and how "x = x + 1" works can be difficult for some students to wrap their minds around. Getting students comfortable/competent with a language and then switching it mid year would be a tough ask for quite a few students.
Keep in mind, many of the students taking Computer Science in high school are not exactly the same students that would have taught themselves to program at 15 and 16. Self-taught students are easy to teach (although they provide their own challenges), but you have to approach things much differently (and often slowly) for students that don't already "think like a programmer".
In BASIC you can say "LET X = X + 1" which really helped me grasp the assignment operator when I was starting out.
We used BlueJ in my comp sci intro courses, but I had already taught myself BASIC in high school using QBASIC and making extensive use of the built-in documentation. It was helpful to have some programming experience coming into it. I had to unlearn a lot of outdated or unfashionable practices, though. If I had learned how to use subroutines instead of relying on GOTO that probably would've helped understand methods a little better.
That's certainly the benefit of having a teacher. :) I was trying to learn from old books and help documentation, where subroutines seemed to be considered a niche feature for more experienced users.
We were forced to use this ide back in the days when I went to school. I never encountered something more worse to use then this "IDE".
Not to mention we were told to use notepad in the beginning... Can't make this sh* up.
From my perspective its very confusing for beginners to switch to a proper IDE after using this. And I will not mind the argument that "proper" IDE are overwhelming.
If you are new to programming most likely everything, including BlueJ, is overwhelming.
And with a good teacher and a good introduction I don't think its too much for beginners to use something like IntelliJ.
Just use the "correct" tools right away.
//edit:
The IDE might improved a lot since the last time I used it.
Didn't wanted to talk bad on BlueJ itself.
My experience was quite the opposite: We used this IDE in the first (maybe two) semesters of my Computer Science bachelor's programme (obviously not for all classes), and it was great. BlueJ allowed us to focus on the modeling and structure aspects of programs. For introduction into OOP it was a very nice tool.
Obviously after a couple of months, it's quite limiting – you don't want to write any proper programs in it, but for educational purposes and classes it's great.
I, also having undergone this horrific treatment, totally agree with this. BlueJ was my first programming editor, as I will not call this an IDE. And because it didn't autocomplete and had an extremely simple debugger I got the hang of Java pretty fast. And we only build really small CLI applications with it anyway. The only thing I missed was auto imports. Especially when you get a little more experienced with Java, this was a bit of a pain.
A nice side effect is that I now sometimes try to race the highlighter/autocomplete. And just see how far I can come without it highlighting or completing. Because I can type pretty quickly and know quite a lot by heart. But that's only because I used BlueJ and thus not relying on autocomplete all the time.
I also used BlueJ in the first semester of CompSci and it was an easy start but I think it can give a false understanding of how things actually work. The fact that you can instantiate objects and call any (public I guess?) method without using code is nice at first but doesn't encourage students to write tests or to concentrate on writing a proper main class. All things that arent't that bad when there's good guidance to the students that this is not all given. Also I'm surprised that this has an actual debugger and not just the inspector, could have used that feature very well but I thought the inspector was all there is.
I am currently being forced to use it for my compsci class and it really is horrible from a UI/UX standpoint (doesn't even have dark mode lol). It does not enforce any syntax style or proper formatting which makes beginners learn that "it doesn't matter" which is wrong imo and leads to horrible looking code.
> It does not enforce any syntax style or proper formatting which makes beginners learn that "it doesn't matter" which is wrong imo and leads to horrible looking code.
This is a good point and IMO "format code on save" should be the default in most IDEs and editors - that way if you need a specific set of formatting rules you can configure them, but you won't end up with no formatting (or different people having different ways of writing code) by default.
I think that Go in Visual Studio Code did something like that by default, where you saved your changes and it also formatted everything. Annoying at first, but I came to appreciate the idea.
You can technically achieve the same with something like Git hooks but setting those up is error prone and can be annoying once people get too trigger happy (e.g. someone eventually putting running tests in Docker containers in there before you can commit your changes).
To me code formatting feels about the same as the tabs vs spaces "debate": if you're having it in the first place, you're possibly doing something wrong. Use tab key for indentation, have the IDE insert whatever is configured for the project/org, be it tabs or spaces (e.g. smart tabs), automate it away.
This is a tool for beginners. Formatting code on save might cause confusion. IMO professionally format on save sounds good if your expecting it. For a beginner they should learn the syntax and concepts. Formatting can be taught later.
There is a world of difference between tools for learning how to code and tools for producing code.
Something students don't always realize is that their teacher doesn't need 30 copies of a program that prints "Hello, World". You are not "producing code", you are "demonstrating your understanding" of the content.
Autocomplete, autoformatting, auto-anything is harmful for the learning process. If the computer does it for you, then how do I know you know how to do it?
Once you can demonstrate that you know how to format your code properly, then those auto-tools can help you, rather than being a crutch.
Once you know "I can solve this problem by using a substring" you can use autocomplete to figure out the exact syntax for the substr() method. But if you're just looking through the auto-complete method list and clicking on things until one of them works... that's not "knowing how to program".
Coming back to BlueJ: I appreciate that beginners have to be taught to format their code properly sometime along the way, but not at the very beginning. If you have errors, warnings, linter hints, typos etc. all being highlighted, I imagine that must be confusing as hell for beginners. Better focus on fixing the syntax errors first (or learning how not to produce any in the first place). Also, over-eager linters such as ESLint can really suck all motivation out of you when writing code. As for automatic formatting, that's fine with languages where it's near-universal like Go, but for Java you should probably refrain from adding it to a tool such as BlueJ, otherwise you will get the opposite of what you wanted (people get used to the IDE doing it for them and then neglect proper formatting when the IDE doesn't).
See it through. I know sometimes at university it can feel like your having your wings clipped, or that your not getting the 'real' experience.
But it won't last forever, and what it does well - conveying often unintuitive OOP concepts - it does do well.
Your course conveners job its to teach the fundamentals, tooling is for you to shake out as you gain experience and scale up, and from their perspective - imagine trying to wrangle random IntelliJ/Eclipse issues with a cohort of 120+ students, for many whom this might be their first introduction to programming!
Scaling things back probably genuinely allows them to provide a better learning on ramp.
I'm still in high school so the scale of everything would probably not be an issue although I see your point of maintainability and showing the relations between classes graphically is probably also helpful when you're still wrapping your head around OOP concepts
Are you already familiar with better IDEs? Then of course using this is painful.
If you're learning to program for the first time, then i believe using a simpler tool is better, because there is less to learn all at once, and less that is hidden from you. I started programming in EditPad Lite, and that was absolutely what i needed until i started tackling larger projects, at which point it was worth spending the time to learn Eclipse.
I hear this. I think much of my early frustrations in programming were things a decent debugger or intellisense would have quickly taught me. That said, having worked with a bunch of folks who got the big nice IDE right away, what I am noticing is they do tend to use the IDE as a crutch. I use my knowledge of the tech to solve a problem efficiently, while they blunder through to a (usually sub-optimal) solution using whatever guard rails the IDE puts in their way. This is a generalization, of course, and even those raised on an IDE can transcend it. But they’re not really being taught to effectively in my opinion.
I started programming in high school, probably around 9th grade, I picked up a book on c at B&N, it was written with devC++ in mind as the IDE.
The next year I took my first "formal" programming class. Programming 1 at my highschool was based on visual basic.net. I had already learned how to make my own "debugger" using console out, but being able to add watches and breakpoints and actually see the internals of my program shift about as I stepped through it was awesome.
Despite having a proper IDE, my Programming 1 class spent all of 1 class period on how to use the debugger built into visual studio.
Having taken programming 2 in high school (java) then Liberty basic in freshman year in college and then back to c/c++ again in college I can say without a doubt programming classes massively undervalue debugging skills.
Once you get your first language under your belt the other languages come easier, as most of them are vastly similar. variables, limits, etc, how things are passed around and referenced change, but the basic function and control structures if then else switch case, for,do,etc are all roughly the same. - edit- at least higher-ish level languages,
I think programming curriculums should include an entire section on debugging. How to isolate specific issues, watches, off by one errors, byref/byval issues, top down order of operations issues, figuring out how a language handles a datatype mismatch etc.
I learned Java with this IDE and thought the class diagram and the color coded blocks helped a lot. I wish VS Code has a similar setup for real projects. I’ve worked in code based where a real time class diagram would of been super helpful.
Same experience in university. I had no prior programming experience and the professor insisting on the use of BlueJ caused me to repeat that course because I did not get the concept of object oriented programming at all.
The following year I got a different prof who used Eclipse and things started making sense.
I'm not sure what the proper didactic concept is to teach programming. I'd love to see some data, because my personal feelings probably aren't of much use.
BlueJ does have a number of concepts that can be useful in the beginning. The UML view of the classes is a nice way to connect something very abstract with the actual code. Scope highlighting is a great idea too - I tried teaching some people to code and scopes seem to be as difficult a concept as classes are. Having the IDE change based on some text you wrote is pretty good too - like seeing relationships form in the UML view, listing public members on classes and so on.
The only problem I see is helping people move on from BlueJ. Some people who struggled a lot learning the basic concepts may feel like they finally managed to find a setup that "works" for them that's mostly based on a task-based understanding:
"I click on the BlueJ icon on my desktop, I click here to create a new class, if something doesn't work I better delete everything and start again because I don't know where to go from there"
Other IDEs aren't necessarily better! What does it actually do under the hood? How do I create a program that I can run outside of the IDE, not to mention on another person's computer?
Maybe that's not the problem of an IDE, rather it's the teacher who needs to include that transition in their course. I remember how back in school/university that was hardly mentioned at all.
blueJ is a terrible first IDE. but mostly because JAVA is a terribly first language for new programmers. New programmers should be focused on variables, control flow, functions and io. The absolute minimum to do something useful. abstraction should come later as the scope of what they are trying to accomplish outpaces their ability to manage complexity. java centric first programming classes are so idiotic it drives me mad. Some of these classes go so far as to model toy problems as MVC using classes when the students aren't even comfortable using a LOOP!!
Drives me crazy. We should be starting them on python in repl.it. easy to get up an running. minimum amount of stuff you need to know to do something interesting.
Java as a first language pushed on new CS students has caused untold damage to the industry.
> Java as a first language pushed on new CS students has caused untold damage to the industry.
I'd argue that the true Dark Times™ were the days before Java.
Forcing students to write Scheme or C as intro languages was far worse.
These days, I'd say something like Python to get the basic concepts down and then moving on to things like Rust or Go then Java, C++, or C# are probably better moves.
I get resistance to C, it is quite simple and straightforward language, but pointers aren't for beginners.
But hey, scheme is nice. No manual memory management, as simple as it comes syntax, very little to get started, excellent REPL, if it were in my power, I'd go back to college and have my first programming class in Scheme.
> But hey, scheme is nice. No manual memory management, as simple as it comes syntax, very little to get started, excellent REPL, if it were in my power, I'd go back to college and have my first programming class in Scheme.
I'd argue that C-style syntax has largely (though not completely) won out. Python is a departure from this for sure, as well as various functional languages, but Scheme and other LISP languages are an order of magnitude more different. The basics like function definitions, not actually quoting both ends of strings in all cases, etc. It's just very different than basically the rest of the languages out there. This alone makes learning with Scheme to start not really better than what this thread is about -- complaints about the way BlueJ was pushed in university to have next to no real-world applicability. Yes, you can get jobs writing Scheme and you can write productive applications. However, you're going to be a step behind everyone else trying to figure out C or C++ for the first time and those syntax semantics matter a great deal when they're essentially reused in 80-90% of other languages out there.
Also, in the pre-Java days "excellent REPL" wasn't really common, so you're really comparing more modern versions and what we have today to the times before Java sort of became the de facto "intro to programming" language.
Sure, it has some pros but I think it was a mistake to make it the intro to CS language of choice, even over something like BASIC or Delphi. In my professional life the closest I've come to needing to write Scheme is in working with LDAP queries.
As someone who learned lisp-like languages well after "baby's first program", what places Scheme in the same group as C in terms of "even worse than Java for n00bs"?
Disagree. Python has is caveats as well. Learning architectural patterns is as important as control flow. I taught Java to beginners for a few summers in college and Java syntax was never a problem. You can code everything in one function if you so desire.
> Java centric first programming classes are so idiotic it drives me mad.
Sorry you're having such hard time :D. When I started first had programming classes we had a few months of a toy programming language called karel++ and then were given C++. Now the point wasn't really to learn C++ as you've pointed out, it's just a language (any language) to get comfortable with sequences of commands, basic logic, loops, etc.
I don't think any progressional language could be quite as good as a purposefully crafted toy/educational language, but I actually think Java is still close to the top. If it wasn't for the 'class Main { public static void main(String[] args) {}}' bit I think it'd be pretty great. For anything a new student needs it's reasonably identical to C or C++ without pointers and segfaults. NPEs are a godsend.
I think python is pretty okay for a first language, it has a lot going for it! Its simple to start. A repl is convenient to experiment. But imho it's probably worth introducing typed variables, braces for scope, a compile step that checks a few things for you pretty early. I think significant whitespace is fine but as with most things in python, the reduced structure makes it look simpler but alse the errors it'll cause are way more frustrating starting out. Way more than missing semicolons.
The only other consideration is JavaScript. But I don't have the imagination for a intro CS class without a terminal prompt assignment.
Consider also Racket scheme! Has a great starter IDE, an absolute barebones teaching variant that exposes the minimum amount of primitives required to do computations, a repl, as well as a typed variant. Has braces for scope, extremely clear error messages with literal arrows tracing exceptions through your code, and is quite amenable to terminal prompt assignments.
I had zero issues learning java in college. but I already had self taught myself python in highschool. all I had to learn was java syntax and OO while I watched others struggle needlessly. python would have been a far gentler introduction before ramping up
I think the reason they make you use Java instead of something like Python, is with Java is explicit whereas with Python lots of things are implicit like type inference.
IMHO the best language to teach with now is Typescript. You get the explicit benefits of Java without the OOP mess.
And some sort of extension of BlueJ is Greenfoot [1]: It is an "IDE" for making simple games using a really simple API[2].
I used it in school for making a game during my A-Levels for my scientific seminar (W-Seminar in german). While the concept is good, the editor is really not that good for anything bigger. You e.g. have no package support in Greenfoot (Or I was not able to find it), and e.g. if you restart a so called "scenario", the JVM does not get reset. Sure I did maybe go to the limits of Greenfoot with my game, but nevertheless it was really fun to work with
Back in 2006-8 I had an NSF teaching fellowship, and my peers and I used BlueJ as an introductory IDE in high school CS classes. BlueJ has a feature called “Object Bench” whereby one can instantiate and invoke methods on an object. The main thing I remember from that period is that Microsoft copied that functionality into Visual Studio, calling it “Object Test Bench”. Microsoft even admitted they were influenced by feedback from BlueJ users. Imitation, flattery, right? Then Microsoft filed a patent covering Object Test Bench. Suffice it to say Kolling et al. weren’t happy, and the news made it to several popular sites (Slashdot, etc.). Having been called out so publicly, and having basically admitted their knowledge of prior art, Microsoft withdrew the patent application.
I personally did not like BlueJ as an IDE, but I found that the module that was built around it at Kent and the speed at which you can test classes you have created in isolation were a great aid for teaching people basic OOP principles.
I used bluej for a while - it was fine as your first IDE as it does not have tons of bells and whistle that overwhelms you. Obviously, as time passes and your skills improve, you will look for better tools. But BlueJ does its job.
I sailed away from java world, which IDEs are being used now? IntelliJ, Netbeans, Eclipse?
IntelliJ is really popular. Eclipse and Netbeans much less so. IntelliJ profits from “networking effects” from other Jetbrains IDEs like WebStorm, CLion etc.
Yeah IntelliJ by far is the most popular at the moment. We have been recommended to use it even by our university (in Italy) for the exam "Algorithms and data structures in Java".
I remember having to use BlueJ at University... I found that it makes programming so much harder. New window for every file, no ctrl+click following references, no auto-formatter, no easy sidebar tree of files...
I ended up using vscode and just copying the files into BlueJ before submitting my assignments.
> I remember having to use BlueJ at University... I found that it makes programming so much harder. New window for every file, no ctrl+click following references, no auto-formatter, no easy sidebar tree of files...
There's something to be said for a very minimal "just get shit done" code editor. I think Thonny[1] falls perfectly in this line though in terms of useful features vs IDE-completeness. It has most of the quality of life improvements you're talking about here but is otherwise an advanced text editor with code highlighting.
I used to nearly exclusively write my code that way actually, using EditPlus and then later Notepad++, both with plugins for syntax and formatting. I found it to be surprisingly productive. Then again, I suspect there's a large overlap between people who are like me and will find it productive and those who like all those distraction-free writing applications out there.
> I ended up using vscode and just copying the files into BlueJ before submitting my assignments.
This I'm curious about. Why would you need to do this? Does BlueJ do something specific with the application that VSCode can't?
There is also Greenfoot[0], created by the authors of BlueJ, that focuses on building 2 dimensional simulations and games. I think Greenfoot is derived from the same source as BlueJ.
We were recommended to use this during our first year of university (2006), Michael was a lecturer so the university must have felt BlueJ a useful introductory programming tool.
Personally I struggled to get to grips with it. While I can appreciate it tries to visualize foundational OOP principles, for someone who already had some experience with various (mainly web programming languages), BlueJ felt too limiting but also broke my mental model of what I should be doing.
If I were to think of it more as an interactive debugger, then maybe I would have had more favourable memories of it. However, a few weeks later I switched to Netbeans and felt far less anxiety that I didn't belong in my course.
Whoa, I thought BlueJ is dead. Turns out it's still under development. Nice.
Used in the university (2004-2005) when I started learning Java as a freshman.
I truly believe that IDEs like this one (including DrJava gag) ruined introductory programming courses. I don't think using a full fat IDE is good either.
Using an IDE from the beginning has resulted in many (maybe even most) of my peers not understanding what actually happens when they compile and run a program, just that they put some text in a box, then click the magic compile and run buttons and some text pops out of the magic output window. They have no concept of how to actually make a useful program or how to distribute said program and run it on someone else's computer. These are never taught, it's just assumed that you know how to do that (as well as be comfortable with *nix) by the time you get to 3000 and 4000 level classes.
That isn't even to mention how Java just isn't a great first programming language. Thankfully I believe they just chaged the introductory programming courses at my university to use Python—probably not using nano and the command line like I'd prefer, but IDLE is okay I guess.
My memories of learning Java at school are tied to learning Eclipse shortcuts. Whenever I had to use some other Java IDE it just felt crippling. Having to use something like this wouldn't have been nice at all.
We used this in school. If I remember correctly one of the intro CS courses was taught by Jennifer Blue and in the catalog it showed up as being taught by “Blue J”. Very fitting.
I think BlueJ is a fantastic intro to Java. Does a good job of teaching the concepts without creating the same IDE dependence of IntelliJ. And not as brutal as JGrasp thankfully.
Used BlueJ, then our Data Structures teacher showed us Eclipse and we were off like rockets.
A good IDE is what makes strongly typed languages far more powerful and productive than any dynamic language. It’s similar to a mechanic upgrading to power tools over hand tools, both will get the job done but one decreases effort.
hah! I have, and I did like my time with it, but ultimately, Eclipse does roughly the same things... and I have all of the keyboard shortcuts burnt into memory. I'll switch, someday!
> Simple: BlueJ has a deliberately smaller and simpler interface than professional environments like NetBeans or Eclipse. This allows beginners to get started more quickly, and without being overwhelmed.
IntelliJ is a great IDE, but it's designed for professional software developers. It can potentially be overwhelming in an educational context when teaching programming to people with no prior experience.
I'd argue the fact an IDE like BlueJ is needed suggests Java isn't an appropriate language for beginners though. And it seems in recent years schools have been preferring Python as a first language which I think is far more appropriate. My teacher used to argue Java is good for beginners because it's a strict OOP language and teaches good habits, but I question how true that is. For one, it falsely assumes OOP is a good approach for an application that asks you to enter your name then prints, "Hello [name]".