-The Java Champions Program consists of a unique group of skilled Java technologists and community leaders sponsored by Oracle. Java Champions come from a broad cross-section of the Java community. They are leaders, influencers and enablers who help grow the size of the Java community. Java Champions are active in many ways such as actively participating in Java projects, engaging with Java User Group communities, speaking at conferences, authoring content, teaching other developers, fostering inclusive participation and so much more.
+The Java Champions Program consists of a unique group of skilled Java technologists and community leaders. Java Champions come from a broad cross-section of the Java community. They are leaders, influencers and enablers who help grow the size of the Java community. Java Champions are active in many ways such as actively participating in Java projects, engaging with Java User Group communities, speaking at conferences, authoring content, teaching other developers, fostering inclusive participation and so much more.
-They are technical and community luminaries; some are Java engineers or architects who are relatively skilled and has lots of experience, or are community builders who take time to build personal, long-lasting relationships that go beyond programming. Java Champions are independent-minded and credible, who embody the best virtues of the Java community including honesty, dedication and sincerity.
+They are technical and community luminaries; some are Java engineers or architects who are relatively skilled and have lots of experience, or are community builders who take time to build personal, long-lasting relationships that go beyond programming. Java Champions are independent-minded and credible, who embody the best virtues of the Java community including honesty, dedication and sincerity.
Java Champions are also able to advocate or influence other developers through their own professional activities (via consulting, teaching, writing, speaking, etc.). They have the opportunity to provide independent, constructive feedback and ideas absent of a competitive agenda that will help Oracle continue to move Java forward. This interchange may be in the form of technical discussions and/or community-building activities with Oracle's Java Advocacy Team.
diff --git a/app/pages/future/innovation/index.md b/app/pages/future/innovation/index.md
index e86051e..8825b54 100644
--- a/app/pages/future/innovation/index.md
+++ b/app/pages/future/innovation/index.md
@@ -7,11 +7,11 @@ subheader_select: innovation
## Amber
-The goal of Project Amber is to explore and incubate smaller, productivity-oriented Java language features that have been accepted as candidate JEPs under the [OpenJDK JEP process](https://openjdk.java.net/jeps/1). This Project is sponsored by the [Compiler Group](https://openjdk.java.net/groups/compiler/).
+The goal of Project Amber is to explore and incubate smaller, productivity-oriented Java language features that have been accepted as candidate JEPs under [JDK Enhancement-Proposal & Roadmap Process](jep:1). This Project is sponsored by the [Compiler Group](https://openjdk.org/groups/compiler/).
-Most Project Amber features go through at least one round of Preview before becoming an official part of Java SE. See [JEP 12](https://openjdk.java.net/jeps/12) for an explanation of the Preview process, and [our tutorial](id:new_features.using_preview) on how to use preview features. For a given feature, there are separate JEPs for each round of preview and for final standardization.
+Most Project Amber features go through at least one round of Preview before becoming an official part of Java SE. See [Preview Features](jep:12) for an explanation of the Preview process, and [our tutorial](id:new_features.using_preview) on how to use preview features. For a given feature, there are separate JEPs for each round of preview and for final standardization.
-Learn more at Project Amber's [Wiki](https://openjdk.java.net/projects/amber/), as well as Inside.java's [Amber page](https://inside.java/tag/amber).
+Learn more at Project Amber's [Wiki](https://openjdk.org/projects/amber/), as well as Inside.java's [Amber page](https://inside.java/tag/amber).
## Loom
@@ -23,7 +23,7 @@ Project Loom is to intended to explore, incubate and deliver Java VM features an
This OpenJDK project is sponsored by the HotSpot Group.
-Learn more at Project Loom's [Wiki](https://wiki.openjdk.java.net/display/loom/Main), as well as Inside.java's [Loom page](https://inside.java/tag/loom).
+Learn more at Project Loom's [Wiki](https://wiki.openjdk.org/display/loom/Main), as well as Inside.java's [Loom page](https://inside.java/tag/loom).
## Panama
@@ -43,7 +43,7 @@ To this end, Project Panama will include most or all of these components:
* tooling or wrapper interposition for safety
* exploratory work with difficult-to-integrate native libraries
-Learn more at Project Panama's [Wiki](https://openjdk.java.net/projects/panama/), as well as Inside.java's [Panama page](https://inside.java/tag/panama).
+Learn more at Project Panama's [Wiki](https://openjdk.org/projects/panama/), as well as Inside.java's [Panama page](https://inside.java/tag/panama).
## Valhalla
@@ -58,7 +58,7 @@ The three main goals are:
A number of people describe Valhalla recently as being "primarily about performance". While it is understandable why people might come to that conclusion -- many of the motivations for Valhalla are, in fact, rooted in performance considerations -- this characterization misses something very important. Yes, performance is an important part of the story -- but so are safety, abstraction, encapsulation, expressiveness, maintainability, and compatible library evolution.
-Learn more at the Valhalla Project [Wiki](https://wiki.openjdk.java.net/display/valhalla/Main), as well as Inside.java's [Valhalla page](https://inside.java/tag/valhalla).
+Learn more at the Valhalla Project [Wiki](https://wiki.openjdk.org/display/valhalla/Main), as well as Inside.java's [Valhalla page](https://inside.java/tag/valhalla).
## ZGC
@@ -81,5 +81,5 @@ At a glance, ZGC is:
At its core, ZGC is a concurrent garbage collector, meaning all heavy lifting work is done while Java threads continue to execute. This greatly limits the impact garbage collection will have on your application's response time.
-Learn more at the ZGC [Wiki](https://wiki.openjdk.java.net/display/zgc/Main), as well as Inside.java's [GC page](https://inside.java/tag/gc).
+Learn more at the ZGC [Wiki](https://wiki.openjdk.org/display/zgc/Main), as well as Inside.java's [GC page](https://inside.java/tag/gc).
diff --git a/app/pages/learn/01_tutorial/01_your-first-java-app/01_getting-started-with-java.md b/app/pages/learn/01_tutorial/01_your-first-java-app/01_getting-started-with-java.md
index e0c1c3d..a26a943 100644
--- a/app/pages/learn/01_tutorial/01_your-first-java-app/01_getting-started-with-java.md
+++ b/app/pages/learn/01_tutorial/01_your-first-java-app/01_getting-started-with-java.md
@@ -24,7 +24,6 @@ toc:
- Going Further {going-further}
description: "Downloading and setting up the JDK, writing your first Java class, and creating your first Java application."
last_update: 2022-10-29
-author: ["JoséPaumard"]
---
diff --git a/app/pages/learn/01_tutorial/01_your-first-java-app/02_building-with-intellij-idea.md b/app/pages/learn/01_tutorial/01_your-first-java-app/02_building-with-intellij-idea.md
new file mode 100644
index 0000000..18d4958
--- /dev/null
+++ b/app/pages/learn/01_tutorial/01_your-first-java-app/02_building-with-intellij-idea.md
@@ -0,0 +1,292 @@
+---
+id: first_app.intellij-idea
+title: Building a Java application in IntelliJ IDEA
+slug: learn/intellij-idea
+type: tutorial
+category: start
+layout: learn/tutorial.html
+subheader_select: tutorials
+main_css_id: learn
+more_learning:
+ youtube:
+ - H_XxH66lm3U
+ - 70_B2DyM8mU
+toc:
+- Overview {overview}
+- Installing IntelliJ IDEA {install}
+- Creating a new project {new}
+- Writing and editing code {edit}
+- Running your application {run}
+- Testing {test}
+- Debugging {debug}
+- Refactoring code {refactor}
+- Documenting code {document}
+- Searching and navigating {navigation}
+- Summary {summary}
+description: "Learn how to code, run, test, debug and document a Java application in IntelliJ IDEA."
+last_update: 2024-04-22
+author: ["MaritvanDijk"]
+---
+
+
+## Overview
+
+An IDE (Integrated Development Environment) allows you to quickly create applications by combining a source-code editor with the ability to compile and run your code, as well as integration with build, test and debug tools, version control systems, and so on. Finally, an IDE will let you search and navigate your codebase in ways your file system won’t.
+
+One of the [most widely used integrated development environments (IDEs)](https://www.jetbrains.com/lp/devecosystem-2023/java/#java_ide) for Java is IntelliJ IDEA. Its user-friendly interface, rich feature set, and vast ecosystem make it an ideal environment for beginners to learn and grow as developers. In this tutorial you’ll learn how to use some of its features to simplify your development process and accelerate your learning curve with Java programming.
+
+
+## Installing IntelliJ IDEA
+
+To install IntelliJ IDEA, download the version you want to use from the [IntelliJ IDEA website](https://www.jetbrains.com/idea/) and follow the instructions.
+Note that IntelliJ IDEA is available in two editions:
+- **_IntelliJ IDEA Community Edition_** - free and open-source. It provides all the basic features for Java development.
+- **_IntelliJ IDEA Ultimate_** - commercial, distributed with a 30-day trial period. It provides additional tools and features for web and enterprise development.
+
+For this tutorial, you can download the Community Edition. For more information on installing IntelliJ IDEA on your OS, see [the documentation](https://www.jetbrains.com/help/idea/installation-guide.html#standalone).
+
+When you launch IntelliJ IDEA for the first time, you’ll see the **Welcome** screen. From here, you can create a new project, open an existing project, or get a project from a version control system (like GitHub).
+
+[](/assets/images/intellij-idea/welcome-screen.png)
+
+To start working with Java, you will need to install a JDK. You can do this yourself, as described in [Getting Started with Java](https://dev.java/learn/getting-started/#setting-up-jdk), or you can do so in IntelliJ IDEA when creating a new project, without having to switch from your IDE and other tools (such as your browser, file system, etc.) to download and configure a JDK.
+
+
+## Creating a new project
+
+We can create a new project from the **Welcome** screen, or we can go to **File | New | Project** in the main menu.
+
+[](/assets/images/intellij-idea/new-project-menu.png)
+
+In the **New Project** wizard, make sure that **Java** is selected on the left-hand side, and give your project a name (for example, `java-demo`).
+Next, we'll select a **Build system**. IntelliJ IDEA supports both Maven and Gradle; the most used build systems for Java. A build tool, like Maven or Gradle, helps you to build your project, and manage any dependencies (like additional libraries) that you want to use in your Java code. Using a build tool will also make it easier to share your application and build it on a different machine. If you don't want to use either, you can use the IntelliJ build system. In this tutorial, let’s create a Maven project.
+
+[](/assets/images/intellij-idea/new-project.png)
+
+To develop a Java application, we’ll need a JDK. If the necessary JDK is already defined in IntelliJ IDEA, select it from the **JDK** list.
+
+If the JDK is installed on your computer, but not defined in the IDE, select the option **Add JDK** from the list and specify the path to the JDK home directory (for example, `/Library/Java/JavaVirtualMachines/jdk-21.0.2.jdk`).
+
+If you don't have the necessary JDK on your computer, select **Download JDK**. In the **Download JDK** popup, specify the JDK vendor (for example, Oracle OpenJDK) and version, change the installation path if required, and click **Download**.
+
+[](/assets/images/intellij-idea/download-jdk-popup.png)
+
+If you select **Add sample code**, a `Main` class which prints out “Hello World” will be added to your project. Leave it unchecked, so we can add our own later.
+
+Once you’re satisfied with your input in the **New Project** popup, click **Create**.
+
+IntelliJ IDEA will create a project for you, with a basic `pom.xml` and a default directory structure for a Maven project with the source folder defined. The `pom.xml` is a file that contains information about the project and configuration details used by Maven to build the project. For more information, see [the Maven documentation](https://maven.apache.org/guides/introduction/introduction-to-the-pom.html).
+
+[](/assets/images/intellij-idea/project.png)
+
+We can see the project structure in the [Project tool window](https://www.jetbrains.com/help/idea/project-tool-window.html) on the left. The `.idea` folder contains your project configuration. The `src` folder contains your code. When you expand that folder, you'll see that IntelliJ IDEA has created a `main` folder for your Java code and a `test` folder for your tests.
+
+Let’s add some code by creating a new class.
+* In the **Project** tool window on the left, select the directory `src/main/java`.
+* To add a new Java class, right-click the **Project** tool window to open the context menu and select **New | Java class**.
+* Name this class `HelloWorld`.
+
+[](/assets/images/intellij-idea/new-java-class.png)
+
+---
+**IDE TIP**
+
+You can add a new Java file using the shortcut **⌘N** (on macOS) or **Alt+Insert** (on Windows/Linux).
+
+---
+
+
+## Writing and editing code
+
+The entrypoint to execute your `HelloWorld` Java program is the main method. Add the main method by typing:
+```java
+public static void main(String[] args) {
+
+}
+```
+I recommend that you type the code, rather than pasting, as that will help you get more familiar with the syntax.
+
+To keep things simple, let's make our program print `Hello World!` to the console and move the cursor to a new line, by adding `System.out.println("Hello World!");` to the method body:
+
+```java
+public static void main(String[] args) {
+ System.out.println("Hello World!");
+}
+```
+
+As you start typing, you’ll notice that IntelliJ IDEA gives you [code completion](https://www.jetbrains.com/help/idea/auto-completing-code.html). It will help you complete the names of classes, methods, fields, and keywords, and other types of completion. Use the arrow keys to select the option you want from the list, and the **Return** (on macOS) or **Enter** (on Windows/linux) key to apply your selection.
+
+[](/assets/images/intellij-idea/hello-world.gif)
+
+IntelliJ IDEA will show you if you’ve typed or selected something that doesn’t compile, or if it sees any other problems. If you press **Alt+Enter** it will offer options to fix the problem. You can use **F2** to move to the next problem, and **Shift+F2** to go to the previous problem. IntelliJ IDEA will help you make sure that your syntax is correct and your code can be compiled, by offering suggestions that are context-sensitive.
+
+[](/assets/images/intellij-idea/alt-enter.png)
+
+To speed up development, we can also [generate code](https://www.jetbrains.com/help/idea/generating-code.html). IntelliJ IDEA can generate constructors, getters and setters, `toString()`, `equals()` and `hashCode()` methods, and more.
+
+[](/assets/images/intellij-idea/generate-code.png)
+
+IntelliJ IDEA will manage the formatting of your code as you write it. If needed, you can explicitly reformat the code, using the shortcut **⌘⌥L** (on macOS) or **Ctrl+Alt+L** (on Windows/Linux).
+
+
+## Running your application
+
+A major benefit of using an IDE is that you can directly run your code without having to first manually compile it on the command line.
+
+You can run the `HelloWorld` application directly from the editor, by clicking the green Run button in the gutter near the class declaration, or using the shortcut **⌃⇧R** (on macOS) or **Ctrl+Shift+F10** (on Windows/Linux).
+
+Alternatively, we can run our application using the green Run button in the top right corner, or using the shortcut **⌃R** (on macOS) or **Ctrl+F10** (on Windows/Linux) to run the latest file.
+
+[](/assets/images/intellij-idea/run.png)
+
+If we want to pass arguments to our application, we can do so in our [Run Configurations](https://www.jetbrains.com/help/idea/run-debug-configuration.html).
+
+To edit your run configurations, select the configuration in the run/debug configuration switcher, by clicking the down arrow next to the current configuration or the three dots to the right of the run configuration, and select **Edit Configurations**.
+
+[](/assets/images/intellij-idea/edit-configurations.png)
+
+The popup **Run/Debug Configurations** appears, and there you can modify JVM options, add program arguments, and many more.
+
+[](/assets/images/intellij-idea/run-config.png)
+
+
+## Testing
+
+Testing your code helps you to verify that the code does what you expect it to do. You can run your application and test it yourself, or add automated tests that can verify your code for you. Thinking about what to test and how, can help you to break a problem up into smaller pieces. This will help you get a better solution faster!
+
+For example, let's say we have a `Calculator` class containing the following method that calculates the average of a list of values, and we want to make sure the average is calculated correctly:
+```java
+public class Calculator {
+
+ public static double average(int[] numbers) {
+ int sum = 0;
+ for (int number : numbers) {
+ sum += number;
+ }
+ double avg = (double) sum / numbers.length;
+ return avg;
+ }
+}
+```
+IntelliJ IDEA makes it easy to add tests to your code. You can navigate to the test for a particular class using the shortcut **⇧⌘T** on macOS or **Ctrl+Shift+T** on Windows/Linux. If no test class exists yet, IntelliJ IDEA will create one for you. This class will be created in the `src/test/java` directory.
+We can select a **Testing library** in the **Create test** popup.
+
+[](/assets/images/intellij-idea/create-test.png)
+
+IntelliJ IDEA supports multiple testing libraries, including [JUnit 5](https://junit.org/junit5/), which is the [most used testing library for Java developers](https://www.jetbrains.com/lp/devecosystem-2023/java/#java_unittesting). If JUnit 5 is not part of your project yet, IntelliJ IDEA will note “JUnit5 library not found in the module.” Click **Fix** to have IntelliJ IDEA fix this for you.
+
+Note that the JUnit 5 dependency `junit-jupiter` is added to the `pom.xml` in the `{{ author.description }}
+{{ author.description | safe }}
Website: {{ author.website }}
diff --git a/app/templates/pages/authors/authors.html b/app/templates/pages/authors/authors.html
index f02b5d5..b898f7b 100644
--- a/app/templates/pages/authors/authors.html
+++ b/app/templates/pages/authors/authors.html
@@ -21,9 +21,15 @@
- {{ a.name }} -
+{{ contents | safe }}
diff --git a/app/templates/pages/learn/tutorial-group.html b/app/templates/pages/learn/tutorial-group.html index 1cddb57..c93971b 100644 --- a/app/templates/pages/learn/tutorial-group.html +++ b/app/templates/pages/learn/tutorial-group.html @@ -36,7 +36,7 @@