Ted Hagos

Campbell Ritchie wrote:Welcome to the Ranch (again).
Don't try to pick subjects and learn them to the exclusion of other topics.

I like all the answers here, but this is my favorite. It's good to have a well-rounded knowledge of programming. I understand you need to move in a priority list. From what I can recall, here's how I started in Android programming.

1.  Get an overview of the Android app's architecture, how it's built and how it's patched together.  It's made up of components (Activities, Services, BroadcastReceivers, Content Providers). You'll find that these components are classes, but they are so much more than just a compilation unit, the Android runtime treats them more than such. You build an application by creating one or more of these components and then making them talk to each other by sending messages/data (via Intents, which is something you will also need to be very familiar with)

2. Build an app with just one UI (which means 1 Activity class only). In this exercise, you'll discover that Android UI (Activities) are built using two things 1) an XML which describes the UI components and 2) a class that handles app logic and events. Put a TextField and Button View (Views are what Android people call widgets).  Learn how to setup OnClickListeners (Listener classes are how Android handles events)

3. Build on your previous exercise (item 2 above) and create a Thread where you will do the processing once the Button is clicked. In here, you'll learn the many ways how Android can delegate processing to background threads (using Java Threads,  Runnables, Handlers and Messages, AsyncTask etc). And then, you'll also discover that you cannot change the UI when you're in a background thread. So you'll discover the techniques on how to go back to the UI Thread to make changes to the UI

After all these, you'll still have lots of things to learn, but I hope, like me, it would have given you some confidence to move forward. Lots of Java topics in 3 steps above; Basic OOP, Interfaces, Anonymous classes for event handling, Threads.

I haven't really tried using Eclipse shortcut keys in IDEA. I'm guessing if you choose to use Eclipse keymaps on IDEA, then all the KB shortcuts will closely resemble that of Eclipse. If you want to cherry pick the KB shorts (some will behave like Eclipse and some will behave like IDEA), you'll need to customize the keymap yourself (which of course, you can do in IntelliJ).

My advise would be to really try to learn the IDEA keyboard shortcuts. Then, use the double shift (Shift Shift) keyboard shortcut to find any action in IntelliJ. In time, it'll become muscle memory, then you might not need the Shift Shift shortcut anymore.

Hope this helps.

Hi David,

Unfortunately, the book doesn't include any chapter on code coverage; but as Roland pointed out, IDEA supports code coverage via plugins.

Intellij has a Coverage plugin that is bundled with IDE - also in the community edition.
https://www.jetbrains.com/help/idea/2021.3/code-coverage.html

Charles O'Leary wrote:Hi Tim,

What do you advise when using Ant 1.X and NOT being allowed the any bandwidth to convert things on the job by learning and converting to Maven or Gradle?  Just picking up IntelliJ itself would be a very tall order (time-wise) for management on the job.  Does IntelliJ play nice and import nicely with Ant 1.X?

Thanks,
Charles

Hi Charles and Tim,

Sorry it took a while to pop in.

If you're really stuck with Ant 1.x, IntelliJ can still work with that (via plugins). So you're still covered. Even you don't get to use Maven or Gradle, the time invested to learn the IDE (which isn't much, by the way) will be worth it. It has lots stuff that's geared towards developer productivity.  

BTW, you don't have to do anything in IDEA to work with Ant; the plugin is already installed (as part of your initial setup). But if you want to check, go to Preference/Settings > Plugins > Ant, see if it's already enabled. After that, you can simply go to View > Tool windows > Ant, from there you can import an existing build.xml.

Hope this helps.

 

Thanks Kevin.

If you find yourself googling for how to do this and that in IDEA, then I think the book will serve you well; especially chapters

5 - Navigation and Generation
6 - Code inspections
7- Refactoring
14 - Customizing IntelliJ
15 - Tips and tricks

These 5 chapters, I think, are geared towards existing users of IDEA.

Thanks,

Ted

Hi KB,

Tim's got it covered. I haven't used Eclipse as much as I use IDEA, I guess I was just biased from the get-go. But from my limited interaction with Eclipse, it seems to cover lots more area than IDEA -- general purpose -- whereas IDEA focuses on less areas; which isn't necessarily a bad thing. The advantage may well be, that IDEA is more focused on very specific tasks e.g. web development, mobile development just to name a few.

I don't think there's a lot of learning curve. You should be able to pick it up pretty quickly. IDEA is gung-ho on keyboard shortcuts. The best way to use the IDE is to learn the keyboard shortcuts you use most.

You can move an Eclipse project into an IDEA project without much difficulty. There is an "import" mechanism in IDEA.

Thanks

Hi, it covers unit testing (JUnit only). It doesn't cover performance testing. It's a good idea though, if I get to write the next edition of this book, I"ll sure include perf test and perhaps some profiling tools. Thanks.

Hi Dave,

Nope. It doesn't cover Docker.  Missed that one when I was working on the book's instructional design. It's a great idea though. If I get to write the next edition of the book, I'll sure include cloud and container techs.

Not too deep. It's basic setup; but it's useful because they cover instructions about the latest versions JavaFX and IDEA itself. At the end of the chapter, you should be be able to create a UI with a label, a textfield and a Button. No event handling. Spoiler alert -- I had some difficulties making Scene Builder work properly. Suppport for Scene Builder (even for IDEA 2021.2) is still spotty. Sometimes it works, sometimes it doesn't.

If you need a step by step guide on how to setup a JavaFX project, how to edit the XML and how to integrate SceneBuilder, chapter 12 of the book covers that. It covers some basic information about JavaFX, but it won't go deep in JavaFX. Hope this helps.

Hi Dave,

Yes it does and it's on by default. The JUnit plugin is part of the installation process. All you have to do is write a class and annotate it with @Test.

Alternatively, you can simply use the context menu on an existing class (cmd + n on macOS | Alt + Insert for windows/linux) -- this is the "Generate" dialog -- then choose "Test". Write your assertions. That's it.

Hi MaryJo, SDET, is that software development engineer in test? If that's the case, you might want to focus on chapters 9 (debugging) and 11 (testing). It talks about the facilities of IDEA that makes creating unit tests and debugging (useful for white-box testing) easier than in any other IDE. IntelliJ is quite big and it may take anyone quite a bit of time to learn its nooks and crannies; but the book isn't a bad start.  

The quickest thing to do to find anything in IntelliJ is to press Shift twice (double shift), then type away.

I just tested a project where I set the JDK initially to 11, compiled then run. Then went to project structure, changed the JDK to 16 (Amazon Corretto), compiled then run. Without problems. I should note that I set both JDKs (11 and 16) using the Download option of IntelliJ (attached pic).