[JeanMo]

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.

[preya2k]

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.

[maxehmookau]

100% agree with this. As a way to learn about OOP concepts from first principles, it was fantastic.

Obviously not something to use as a professional, but as a learning tool it was unmatched.

[alex3305]

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.

[vestrigi]

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.

[kjeetgill]

That's fascinating, I don't think we got into real OOP stuff until much later. Definitely not in the first year I think.

[3nt3]

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.

[KronisLV]

> 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.

[mdmglr]

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.

[hdctambien]

I wish I could upvote this 100 times.

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".

[rob74]

Go has a built-in tool for that (go fmt).

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).

[jackpeterfletch]

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.

[3nt3]

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

[twic]

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.

[twodave]

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.

[davidork]

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.

[mdmglr]

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.

[SomeBoolshit]

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.

[aspyct]

Same here. I had been using eclipse and codeblocks for years, yet was forced to use this thing.

It's probably super nice for beginners, because it removes a ton of friction. But why force people?

[pavo-etc]

Used it in 2020 for my uni, still utter dogshit.