Česky   |  Deutsch   |  English   |  Español   |  Français   |  Indonesia   |  日本語   |  한글   |  Polski   |  Português (BR)   |  Türkçe   |  中文   |  正體中文   |  Your Language  
PlanetNetbeans
Planet NetBeans is an aggregation of NetBeans related musings from all over the Blogosphere.
Feeds
[RSS 1.0 Feed] [RSS 2.0 Feed]
[FOAF Subscriptions] [OPML Subscriptions]
Do you blog about NetBeans ? Add your blog to PlanetNetBeans.
Feed Subscriptions
APIDesign - Blogs (feed)
David R. Heffelfinger (feed)
Carsten Zerbst's Weblog (feed)
Winston Prakash's Weblog (feed)
NetBeans – Michael's blog (feed)
DukeScript (feed)
ProNetBeans (feed)
Paulo Canedo » NetBeans English (feed)
NetBeans – NetBeans Ruminations (feed)
Anchialas' Java Blog (feed)
markiewb's blog (feed)
Need to find a title (feed)
Category: NetBeans | Software and Science (feed)
Roger Searjeant's blog (feed)
Adam Bien (feed)
Inspiration and Expression » Netbeans (feed)
Bernhard's Weblog (feed)
Michel Graciano's Weblog (feed)
Ramon.Ramos (feed)
Ozone and Programming » netbeans (feed)
Arun Gupta, Miles to go ... (feed)
Geertjan's Blog (feed)
.JARa's Bilingual Weblog (feed)
JavaFX Composer (feed)
The Java Jungle (feed)
Jesse Glick (feed)
Martin Grebac (feed)
The NetBeans Community Podcast (feed)
NetBeans Profiler (feed)
NetBeans for PHP (feed)
NetBeans Web Client (feed)
Rechtacek's (feed)
Virtual Steve (feed)
The Aquarium (feed)
Tinuola Awopetu (feed)
Insert Witty Irony Here (feed)
Netbeans – Gualtiero Testa (feed)
netbeans – James Selvakumar’s Blog (feed)
NetBeans – nB gUru (feed)
netbeans – Newsintegrator Blog (feed)
NetBeans – Praxis LIVE (feed)
NetBeans – TechAshram (feed)
Netbeans – There's no place like 127.0.0.1 (feed)
Anuradha (feed)
Netbeans6/6.5 my best practices (feed)
Java Evangelist John Yeary (feed)
Neil's Dev Stuff (feed)
Computer says null; (feed)
NetBeans Adventures, Java and more (feed)
NetBeans – John O'Conner (feed)
NetBeans Community Docs Blog (feed)
The Netbeans Experience (feed)
NbPython/ jpydbg / pymvs (feed)
Shanbag's Blog (ರಜತ ಲೋಕ) (feed)
Wade Chandler's Programming Blog (feed)
Devlin's Lab (feed)
Big Al's Blog (feed)
Code Snakes (feed)
In perfect (spherical) shape (feed)
Van Couvering Is Not a Verb (feed)
Diego Torres Milano's blog (feed)
Vroom Framework (feed)
Messages from mrhaki (feed)
Jeff's Blog (feed)
Manikantan's Netbeans (feed)
Oliver Wahlen's Blog (feed)
Shuttle between Galaxies (feed)
Welcome to my live... (feed)
Devel Blog (feed)
diamond-powder (feed)
Antonio's blog (feed)
Where's my Blog?!

Powered by:    Planet

Last updated:
December 08, 2016 07:09 AM
All times are UTC

Sponsored by
sponsored by Oracle

visit NetBeans website
Geertjan's Blog - December 07, 2016 09:53 PM
Simple JSON and ojListView Sample

Simple sample to create ojListView from a JSON file (which I copied locally from here) and therefore looks like this:

{"employees":[
    {"firstName":"John", "lastName":"Doe"},
    {"firstName":"Anna", "lastName":"Smith"},
    {"firstName":"Peter", "lastName":"Jones"}
]}

Here's the business logic:

define(['text!../data/employees.json',
    'ojs/ojcore', 'knockout', 'jquery',
    'ojs/ojlistview',
    'ojs/ojarraytabledatasource'],
        function (file, oj, ko, $) {
            function DashboardViewModel() {
                var self = this;
                self.data = [];
                var content = JSON.parse(file);
                var employees = content.employees;
                for (var i = 0; i < Object.keys(employees).length; i++) {
                    var employee = employees[i];
                    self.data.push({
                        first: employee.firstName,
                        last: employee.lastName
                    });
                }
                self.dataSource = new oj.ArrayTableDataSource(
                        self.data,
                        {idAttribute: "first"}
                );
            }
            return new DashboardViewModel();
        }
);

And the view:

<ul data-bind="ojComponent: {
               component: 'ojListView',
                  data: dataSource,
                  item: {template: 'employee_template'},
                  selectionMode: 'single'}">
</ul>
<script type="text/html" id="employee_template">
    <li>
        <h3 data-bind="text: first"></h3>
        <span data-bind="text: last"></span>
    </li>
</script>

DukeScript - December 07, 2016 09:53 AM
New Version of Maven Archetypes

There’s a new version (0.14) of our Maven Archetypes available. Users of the DukeScript Plugin for NetBeans don’t need to change anything. The Wizard will automatically use the latest version.

The latest version has some minor changes in the projects created. For example the CSS is now separate from the HTML in the basic archetype for convenience. There are also some updates to use the latest versions of our test infrastructure and the CRUD-archetype now has a sample integration test. BrowserRunner is used to run the test with all available presenters.

Try it with NetBeans or from commandline:

mvn archetype:generate 
	-DarchetypeGroupId=com.dukescript.archetype
	-DarchetypeArtifactId=crud4j-archetype 
	-DarchetypeVersion=0.14

Adam Bien - December 07, 2016 07:14 AM
Load Balancing Microservices With Docker, nginx and TomEE

nginx can be used as HTTP server and as a load balancer at the same time. In this screencast I used nginx to share the load between two TomEE 7.0.2 instances on Docker.

The Dockerfiles in this screencast were borrowed from: docklands. Binary images are also available from: hub.docker.com/u/airhacks/. The ping healthcheck is directly available from github.com/AdamBien/ping

Also see how HA Proxy can be used to load balance Java EE microservices.

You want to learn more about Java EE and Microservices? Checkout: Java EE Microservices. Is Munich's airport too far? Learn from home: javaeemicro.services.


Real World Java EE Workshops [Airport Munich]>

DukeScript - December 06, 2016 12:00 PM
User Objects in the @Model

We often get questions about a specific limitation of our ViewModels: The classes generated by the @Model annotation don’t allow custom inheritance. This means they cannot subclass an existing class or implement an interface. And more important, also the @Properties of the class can only be primitives, Strings, Enums or @Models.

These questions often come up, when somebody is porting an application from Swing or JavaFX to DukeScript. So our first example will model a typical scenario: We have a menu bar in our existing application. Each menu item typically has some MenuAction assigned that will be called when the user selects it. Let’s assume that in our original application these MenuActions implement an interface:

public interface MenuAction {
    public void performAction();
}

In DukeScript we cannot add a MenuAction Property, so one way to deal with it would be to create a registry that keeps references to the actions:

@Model(className = "MenuItem", properties = {
        @Property(name = "name", type = String.class),
        @Property(name = "id", type = String.class)})
    public static class MenuItemVMD {

        @Function
        static void performAction(MenuItem data) {
            ActionManager.getMenuAction(data.getId()).performAction();
        }
    }

But that’s ugly. We don’t want to set up registries like that for everything and keep Actions and their ids in sync. A better way to deal with it is the “instance” attribute of the @Model annotation. It allows you to keep private state for the instance of your generated Model (MenuItem) in the class that defines it (MenuItemVMD):

@Model(className = "MenuItem", instance = true, properties = {
        @Property(name = "name", type = String.class)})
    public static class MenuItemVMD {

        private MenuAction action;
        
        @ModelOperation void setAction(MenuItem data, MenuAction action){
            this.action = action;
        }
        
        @Function void performAction(MenuItem data) {
            action.performAction();
        }
    }
}

Notice how we’re no longer using static methods. This is because now we create one instance of MenuItemVMD per MenuItem. So every instance of MenuItem can now store it’s private state in an instance of MenuItemVMD. The @ModelOperation annotation generates a new method in the MenuItem. Now you can set the MenuAction like this:

MenuItem open = new MenuItem(strValue);
open.setAction(new MenuAction() {
    @Override
    public void performAction() {
        doSomething();
    }
});

Our second example is a Tree structure. Let’s assume we have a ViewModel for that:

@Model(className = "TreeNode", instance = true, properties = {
    @Property(name = "children", type = TreeNode.class, array = true)
    , @Property(name = "name", type = String.class)
})
public class TreeNodeVMD {

    UserObject userObject;
    
    @ModelOperation void setUserObject(TreeNode data, UserObject userObject){
            this.userObject = userObject;
    }

    @ComputedProperty boolean isLeaf(List<File> children){
        return children.isEmpty();
    }
}

Again we can now add methods that act directly on the userObject without any indirection or mapping involved.

Adam Bien - December 06, 2016 07:19 AM
Accidental Spring Evangelism, Rolling Updates, Log Management, Exception Factories, Docker, Queuing Choices or 33rd airhacks.tv

New live viewers record of 191 was set during the 33rd airhacks.tv. The show started with explanation of accidental Spring 5.0 evangelism, then I discussed the questions ranging from central log management, over rolling updates, project specific docker images to queuing choices in microservices and lombok.

Any questions left? Aks now https://gist.github.com/AdamBien/a7a638836c24b9a80133418844a1c2ed .

See you at Java EE Workshops at Munich Airport, Terminal 2 or Virtual Dedicated Workshops / consulting. Is Munich's airport too far? Learn from home: airhacks.io.


Real World Java EE Workshops [Airport Munich]>

Adam Bien - December 05, 2016 05:18 AM
Java EE 8 News, Central Logs, Layering, Util, ExceptionFactories, JDBC in Docker, DTOs, Lombok--Or 33rd airhacks.tv

News, opinions and answers for the questions or the 33rd airhacks.tv, Monday, December 5th, 6 pm CET, (checkout past episodes):

  1. Java EE 8 news
  2. Managing logs in central location
  3. About layering: @ApplicationScoped for services?
  4. Why I created an ExceptionFactory--a long time ago.
  5. Util packages and classes
  6. Modal windows in JavaFX and background threads
  7. Managing JDBC drivers in Docker
  8. How to run a DB in a container?
  9. To share or not to share a DB
  10. Managing private docker images
  11. DTOs vs JSON-P for partial data transfer
  12. Microservices: queuing choices -- JMS or not
  13. Rolling updates with Java EE and docker
  14. Dealing with bloat: lombok, IDE or what?

The questions above are going to be answered during the next "Airhacks Q & A" http://airhacks.tv live. You can subscribe to the channel and / or for the next event: http://www.ustream.tv/channel/adambien (both is optional, no registration required to watch this event live).

See you at Java EE Workshops at Munich Airport, Terminal 2 or Virtual Dedicated Workshops / consulting. Is Munich's airport too far? Learn from home: airhacks.io.
Real World Java EE Workshops [Airport Munich]>

Adam Bien - December 04, 2016 10:14 AM
TomEE 7.0.2 Full--Docker Smoke Test

TomEE 7.0.2 Plus (=everything, Java EE 7 full profile, not certified) works well on docker:

  1. 59 MB zip download
  2. Installation is a one-liner in Dockerfile (curl + unzip)
  3. Thin-WAR deployment is supported, what results in fast docker builds (~100ms) and tiny docker images. A single ping.war image takes 9.85 kB on disk
  4. Lightning fast docker image startup: Server startup in 1790 ms (ping WAR deployment included)
  5. Memory footprint is negligible
TomEE 7.0.2 Dockerfiles are available from docklands. Docker images can be directly downloaded from: hub.docker.com/u/airhacks and started with e.g. docker run -d -p 8080:8080 --name tomee-ping airhacks/tomee-ping.

TomEE is production-ready--commercial support is available.

See you at Java EE Workshops at Munich Airport, Terminal and particularly at Java EE 7 Microservices. Is MUC too far? Checkout: javaeemicro.services
Real World Java EE Workshops [Airport Munich]>

DukeScript - December 03, 2016 12:00 PM
Native Installers with DukeScript

This Tutorial was contributed by Ruslan López Carro, a Software Development professional at UNICOM, and a very active and valued member of the DukeScript community. Here’s a link to his original blog post:

For this tutorial we’ll create a Java powered native desktop app with HTML GUI using netbeans and my Windows 10 computer in less than 30 minutes using the Dukescript sample code.

We’ll create the native app with Dukescript in record time. Dukescript is a client side technology based in Java and mainly on JavaFx to provide a backend with Java and a frontend with HTML5.

You should have Inno and Wix Toolset to create the app and the installer directly from maven pom file.

To install Inno Setup:

  1. Download ispack-5.5.3.exe from the Inno Setup Downloads page.
  2. Double-click the file to launch the installer.
  3. Accept the Inno Setup license agreement and click Next.
  4. Follow the instructions in the install wizard for installing Inno Setup.

To install WiX:

  1. Download wix37.exe from the WiX Toolset – Download page.
  2. Double-click the file to launch the installer.
  3. Follow the instructions in the install wizard for installing WiX.

You need to install the “Dukescript project wizzard” plugin and then

Add Inno Setup and/or WiX to the system Path variable:

  1. On Windows 7, select Start > Computer > System Properties > Advanced system settings.
  2. Select the Advanced tab and click the Environment Variables button.
  3. In the System Variables pane, double-click the Path variable.
  4. In the Edit System Variable dialog box, add a semicolon followed by a new path to the Variable value field (for example, C:\Program Files (x86)\Inno Setup 5 or C:\Program Files (x86)\WiX Toolset v3.6\bin).
  5. Click OK to close all the open dialog boxes.

Dukescript App Native Packaging

Create a new dukescript application from new project wizzard and use the sample hello world project with knockout:

new dukescript project

Name it nativeds:

new dukescript project

No platforms selected, so only javafx version will be available. It will generate three projects, the general project, the javafx project and the javascript libraries project.

dukescript project in NetBeans

Add a plugin to maven’s pom file generated at http://javafx-maven-plugin.github.io/

maven plugin tag:

<plugin>
    <groupId>com.zenjava</groupId>
    <artifactId>javafx-maven-plugin</artifactId>
    <version>8.1.4</version>
    <configuration>
        <mainClass>org.javapro.nativeds.Main</mainClass>
        <verbose>true</verbose>
        <vendor>javapro.org</vendor>
        <nativeReleaseVersion>0.1</nativeReleaseVersion>
        <additionalAppResources>${project.basedir}/src/main/webapp</additionalAppResources>
    </configuration>
    <executions>
        <execution>
            <!-- required before build-native -->
            <id>create-jfxjar</id>
            <phase>package</phase>
            <goals>
                <goal>build-jar</goal>
            </goals>
        </execution>
        <execution>
            <id>create-native</id>
            <phase>package</phase>
            <goals>
                <goal>build-native</goal>
            </goals>
        </execution>
    </executions>
</plugin>

The final result will look like this:

The final native app

Full client project’s POM

<?xml version="1.0"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.javapro</groupId>
        <artifactId>nativeds-pom</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <groupId>org.javapro</groupId>
    <artifactId>nativeds</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>bundle</packaging>

    <name>nativeds General Client Code</name>

    <properties>
        <netbeans.compile.on.save>all</netbeans.compile.on.save>
        <project.mainclass>org.javapro.nativeds.Main</project.mainclass>
        <exec.java.bin>${java.home}/bin/java</exec.java.bin>
        <exec.debug.arg>-Ddebug=false</exec.debug.arg>
    </properties>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.felix</groupId>
                <artifactId>maven-bundle-plugin</artifactId>
                <version>2.4.0</version>
                <extensions>true</extensions>
                <configuration>
                    <instructions>
                        <Export-Package>org.javapro.nativeds</Export-Package>
                        <Bundle-SymbolicName>org.javapro.nativeds</Bundle-SymbolicName>
                    </instructions>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.19.1</version>
                <configuration>
                    <junitArtifactName>com.dukescript.api:junit-osgi</junitArtifactName>
                    <systemPropertyVariables>
                        <fxpresenter.headless>true</fxpresenter.headless>
                    </systemPropertyVariables>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.4</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>${project.mainclass}</mainClass>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>lib/</classpathPrefix>
                            <useUniqueVersions>false</useUniqueVersions>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <artifactId>maven-source-plugin</artifactId>
                <version>2.2.1</version>
                <executions>
                    <execution>
                        <id>attach-sources</id>
                        <phase>post-integration-test</phase>
                        <goals>
                            <goal>jar-no-fork</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.2.1</version>
                <configuration>
                    <executable>${exec.java.bin}</executable>
                    <classpathScope>test</classpathScope>
                    <arguments>
                        <argument>-classpath</argument>
                        <classpath/>
                        <argument>-javaagent:${project.build.directory}/springloaded.jar</argument>
                        <argument>-noverify</argument>
                        <argument>-Dbrowser.rootdir=${basedir}/src/main/webapp/</argument>
                        <argument>-Dnetbeans.inspect.port=${netbeans.inspect.port}</argument>
                        <argument>${exec.debug.arg}</argument>
                        <argument>${project.mainclass}</argument>
                    </arguments>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>2.10</version>
                <executions>
                    <execution>
                        <id>copy</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy</goal>
                        </goals>
                        <configuration>
                            <artifactItems>
                                <artifactItem>
                                    <groupId>org.springframework</groupId>
                                    <artifactId>springloaded</artifactId>
                                    <version>1.2.3.RELEASE</version>
                                    <type>jar</type>
                                    <overWrite>false</overWrite>
                                    <destFileName>springloaded.jar</destFileName>
                                </artifactItem>
                            </artifactItems>
                            <outputDirectory>${project.build.directory}</outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.4</version>
                <executions>
                    <execution>
                        <id>web-pages</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                        <configuration>
                            <descriptors>
                                <descriptor>src/main/assembly/webpages.xml</descriptor>
                            </descriptors>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <dependency>
            <groupId>org.netbeans.html</groupId>
            <artifactId>net.java.html</artifactId>
            <version>${net.java.html.version}</version>
        </dependency>
        <dependency>
            <groupId>org.netbeans.html</groupId>
            <artifactId>net.java.html.json</artifactId>
            <version>${net.java.html.version}</version>
        </dependency>
        <dependency>
            <groupId>org.netbeans.html</groupId>
            <artifactId>net.java.html.boot</artifactId>
            <version>${net.java.html.version}</version>
        </dependency>
        <dependency>
            <groupId>org.netbeans.html</groupId>
            <artifactId>net.java.html.sound</artifactId>
            <version>${net.java.html.version}</version>
        </dependency>
        <dependency>
            <groupId>org.netbeans.html</groupId>
            <artifactId>ko4j</artifactId>
            <version>${net.java.html.version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.javapro</groupId>
            <artifactId>nativeds-js</artifactId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>org.netbeans.html</groupId>
            <artifactId>net.java.html.boot.fx</artifactId>
            <version>${net.java.html.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>com.dukescript.api</groupId>
            <artifactId>junit-osgi</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.dukescript.api</groupId>
            <artifactId>junit-browser-runner</artifactId>
            <version>${junit.browser.version}</version>
            <scope>test</scope>
            <type>jar</type>
        </dependency>

        <!-- Nashorn presenter for BrowserRunner
        <dependency>
          <groupId>org.netbeans.html</groupId>
          <artifactId>net.java.html.boot.script</artifactId>
          <version>${net.java.html.version}</version>
          <scope>test</scope>
          <type>jar</type>
        </dependency>
        -->
    </dependencies>
    <profiles>
        <profile>
            <id>desktop</id>
            <dependencies>
                <dependency>
                    <groupId>org.netbeans.html</groupId>
                    <artifactId>net.java.html.boot.fx</artifactId>
                    <version>${net.java.html.version}</version>
                    <scope>runtime</scope>
                </dependency>
            </dependencies>
            <build>
                <plugins>
                    <plugin>
                        <artifactId>maven-assembly-plugin</artifactId>
                        <version>2.4</version>
                        <executions>
                            <execution>
                                <id>distro-assembly</id>
                                <phase>package</phase>
                                <goals>
                                    <goal>single</goal>
                                </goals>
                                <configuration>
                                    <descriptors>
                                        <descriptor>src/main/assembly/javafx.xml</descriptor>
                                    </descriptors>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                    <plugin>
                        <groupId>com.zenjava</groupId>
                        <artifactId>javafx-maven-plugin</artifactId>
                        <version>8.1.4</version>
                        <configuration>
                            <mainClass>org.javapro.nativeds.Main</mainClass>
                            <verbose>true</verbose>
                            <vendor>javapro.org</vendor>
                            <nativeReleaseVersion>0.1</nativeReleaseVersion>
                            <additionalAppResources>${project.basedir}/src/main/webapp</additionalAppResources>
                        </configuration>
                        <executions>
                            <execution>
                                <!-- required before build-native -->
                                <id>create-jfxjar</id>
                                <phase>package</phase>
                                <goals>
                                    <goal>build-jar</goal>
                                </goals>
                            </execution>
                            <execution>
                                <id>create-native</id>
                                <phase>package</phase>
                                <goals>
                                    <goal>build-native</goal>
                                </goals>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>
</project>

Congratulations! If you reached this far it means that now you can create a native app with Dukescript technology.

Thanks to Ruslan for this great tutorial!

Adam Bien - November 30, 2016 05:55 PM
Slicing The Monolith--With Java EE And Docker

Andreas, please introduce yourself

My name is Andreas Enbohm and been working as software developer and consultant for almost 15 years. Since three years ago I’m running my own company assisting various companies with coding, mentoring and methodology improvements. I’d like to call myself a programmer, but often clients defines my role as a technical/programming architect.

What are you building with Java EE?

I’ve ben involved with many types of applications based on Java EE. From eCommerce websites and web portals, to batch processing systems and core backend systems within telecom- and manufacturing industry. Currently I’m involved in refactoring and evolving a quite large self-service portal within the telecom business. The portal could be considered a big monolith with around 50 integrations with various backed systems (databases, IMS systems, CRM systems, etc). We are currently trying to slice the portal into smaller manageable pieces, what could be referred as ”right-sized” service architecture. We don’t really know the number of slices we’re going to end up with, but we think that somewhere around 10-15 services would be a good start. The foundation for these new services are Java EE along with Docker which I have found to be a perfect match! I’m specially keen on using uberjars and for this we utilise WildFly Swarm. With Docker Swarm mode we get the speed we need to deploy these services along with service discovery, failover, clustering, etc. which is nice. However, one big challenge I see is the monitoring and logging when building application this way. Most likely we will need tools to support us here and I’m investigating if the ELK stack (Elasticsearch, Logstash, Kinbana) can solve this problem. And not to forget, we use Swagger to document all our services which I find very easy and just works!

Can you share with us some geeky numbers like e.g. TX per seconds, heap sizes, thinnest WARs etc -- whatever Java EE devs might find interesting.

In this project the number of transaction are fairly low (around a few per seconds) so not much to brag about here. What is more interesting is maybe that the initial code was written in 2001 (using Java 1.3 and JBoss 3) and many old parts is still healthy and used! The portal has during the year gone through major platform- and application server updates. From Java 1.3 to Java 5, 6, 7 and 8 including various JBoss and Apache Tomcat upgrades with basically no or very little code modifications. This really shows that Java is a really long term platform to build upon! When it come to the newer parts the fat/uber jar services are between 40-120 MB and the services built as non-fat ones are ranging from ca 50KB to 10 MB depending amount of libraries included.

Are you happy with Java EE so far? Is Java EE productive?

I have been using Jave EE for 10+ years now. I’m definitely productive and like it. Frameworks like Arquillian makes testing really easy and many application servers are getting really lightweight and easy to manage. However, I have a few concerns about the evolvement of Java EE 8 (and beyond) and feel that in the accelerating pace of software industry, the Jave EE standards might need to speed up a bit. Then there are some parts I’ve been waiting for really long in Java EE such as caching (JSR107) which I really hope to see as part of Java EE 8.

Which application servers, tools or IDEs are you using?

We are currently using Apache Tomcat for the main part of the web portal (JSP pages) and WildFly (incl. Swarm) for the new (micro)-services. Eclipse is the IDE of my choice when developing Java-code and DbVizualizer for database management. Along with Maven, Jenkins, Git and Gerrit I basically got what I need :). There are of course a bunch of other tools I use from time to time but these ones I’m using on a daily basis.

You are using Docker together with Java EE in production. What is your experience so far?

We have been running Docker containers for a couple of month now in production and have not seen any concerns or issues so far. Memory and CPU footprints are low as is the ”overhead” of Docker (if any). Challenges for us are how to gather information (e.g. logs, health status) and how to share persistent data between containers. Also, in the long run, we think some GUI for Docker Swarm mode is needed but have not yet found anyone to support our demands. Shipyard or Rancher might be the way forward but we have yet to decide. But so summarise, I really think Docker, and to be able to treat infrastructure as code along with Java EE, is a really big step forward (kind of a new era) in software development.

How important are standards for you? Does your application depend on application server specific APIs?

For me standards are important. During the years I’ve been using many custom framework/APIs (which has been abandoned or not supported anymore) and this can be a real pain especially from an enterprise application view which might live for many years. Another problem that might occur without standards is vendor lock-in. When using standards, you often minimise these problems which means freedom to switch implementation without touching the actual code. I often avoid usage of any specific/custom APIs, but if needed I try to encapsulate it as much as just possible.

Which Java EE APIs are you using in your products?

The most widely used ones are JSP, Servlet, CDI, EJB, EL (expression language), JAX-RS and JSTL. In the future I believe I will more and more use the MicroProfile (JAX-RS, CDI, JSON-P) baseline for Java EE services.

Take a look at the Java EE 8 APIs. Which of the APIs are most interesting / important to you?

If I had to pick three ones I would go with these:

  • JSR 107 JCACHE (because it is just so fundamental in enterprise development)
  • JSR 375 Security API (because today it is confusing but business critical)
  • JSR 367 (because JSON is such an important exchange format)

Can you share any resources (blogs, etc feel free to promote yourself) with us?

You can follow me on twitter (@enbohm) or see some of my presentations on SlideShare (www.slideshare.net/enbohm) or GitHub (github.com/enbohm). Some of my presentations are internal ones (not shared in public) but you might see me talking at some Java conference soon :)

Andreas, thank you for the inteview!


Real World Java EE Workshops [Airport Munich]>

NetBeans – Michael's blog - November 29, 2016 09:55 PM
JUGC Event Java Security

The Java User Group Cologne is a vital community. On Mon, 28th Nov 2016 we had an event about Java Security. First Dominik Schadow talked about Defense in depth. He showed how to protect a web application on different layers, from the frontend over the network to the backend.  It’s not only our software where … Continue reading "JUGC Event Java Security"

Adam Bien - November 29, 2016 06:43 AM
HTTP Status Code Test Service: statustest

statustest is a service which responds with a HTTP status code sent as HTTP status header, e.g.


curl -i -H"status:205" http://localhost:8080/statustest/resources/statuses

responds with:

HTTP/1.1 205 Reset Content
Server: Payara Micro #badassfish
Date: Sun, 27 Nov 2016 09:08:20 GMT


statustest comes as a 4.1 kB WAR and is also available as docker image: docker run -d -p 8080:8080 airhacks/statustest from http://hub.docker.com/u/airhacks.

JAX-RS rulz was tested with statustest, as well as, the other way round. Statustest was also used to test error behaviour of various HTTP JavaScript libraries in reactjs and angular 2 projects.

See you at Java EE Workshops at Munich Airport, Terminal 2, particularly at: Java EE Testing. Is MUC too far? Checkout the online version: javaeetesting.com!


Real World Java EE Workshops [Airport Munich]>

Adam Bien - November 28, 2016 02:02 AM
Custom Matchers, Better Messages: JAX-RS Client Rulz v0.0.4 released

The v0.0.4 release of the JUnit JAX-RS Rules 13kB JAR comes with additional matchers: clientError(), redirection(), informational() and other(), as well as, improved matcher messages, like e.g.


Expected: is 2xx family of successful responses
but: Internal Server Error 500 returned

Installation:


<dependency>
	<groupId>com.airhacks.rulz</groupId>
	<artifactId>jaxrsclient</artifactId>
	<version>v0.0.4</version>
	<scope>test</scope>
</dependency>

Sample usage:


import static com.airhacks.rulz.jaxrsclient.HttpMatchers.successful;

public class JAXRSClientProviderTest {

    @Rule
    public JAXRSClientProvider provider = JAXRSClientProvider.buildWithURI("http://adambien.blog");

    @Test
    public void pingJavaAndVerifyWithMatcher() {

        Response response = (...)
        assertThat(response, is(successful()));
    }


Meet rulz at Java EE 7 Testing and Code Quality workshop at MUC airport.

Junit rules are also explained in the episode "JAX-RS Rules For JUnit" of the online Effective Java EE 7 workshop and episodes "AOP For JUnit - Writing Custom Rules" and "JAX-RS Test Rules" of the online version of Java EE Testing workshop.


Real World Java EE Workshops [Airport Munich]>

Adam Bien - November 25, 2016 08:39 AM
New Java EE Related Docker Images Arrived: Docklands

New Docker images arrived. In addition to the following servers:

Recently also Dockerfiles for: were added.

Docklands Dockerfiles and images are used during the javaeemicro.services online workshop, and during the Java EE Microservices workshop at MUC airport.

The images are directly available from: hub.docker.com/u/airhacks, see usage.

See Docklands in action at Oredev: Slideless Microsevices and Java EE 7 Application Servers vs. Plain "Hello World" screencasts.


Real World Java EE Workshops [Airport Munich]>

Adam Bien - November 22, 2016 08:18 AM
Adding And Substracting Path Instances With Java

Method resolve adds Path instances and is useful to create absolute paths. The method relativize substracts Path instances and is useful to remove the root component from the absolute path:


import java.nio.file.Path;
import java.nio.file.Paths;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;
import org.junit.Test;


public class PathTest {

    @Test
    public void addPath() {
        Path javaFile = Paths.get("com", "airhacks", "PathsTest.java");
        Path root = Paths.get("src", "main", "java");

        Path absolute = root.resolve(javaFile);

        String expected = "src/main/java/com/airhacks/PathsTest.java";
        String actual = absolute.toString();
        assertThat(actual, is(expected));
    }

    @Test
    public void substractPath() {
        Path absolute = Paths.get("src/main/java/com/airhacks/PathsTest.java");
        Path root = Paths.get("src", "main", "java");

        Path relative = root.relativize(absolute);

	//ignoring the OS-specific separator
        String expected = "com/airhacks/PathsTest.java";
        String actual = relative.toString();
        assertThat(actual, is(expected));
    }

}


See you at Java EE Workshops at Munich Airport, Terminal 2 or Virtual Dedicated Workshops / consulting. Is Munich's airport too far? Learn from home: airhacks.io.


Real World Java EE Workshops [Airport Munich]>

Adam Bien - November 21, 2016 11:35 AM
How Many "Util"(-ities) Classes Ship With Java 8?

The Util name is considered evil. So, how many "Util*" classes are shipped with Java 8?

Exactly 8 out of 4240. It is remarkable how well most of the Java classes are named. There are only eight exceptions, but most of them could be easily renamed to emphasize their responsibility:

  1. AttributeSetUtilities: extension of AttributeSet functionality from Java's printing library. This either decorates the AttributeSet or validates that. AttributeSetViews or AttributeSetViewProvider would be a better name.
  2. BasicGraphicsUtils: gathers "BasicGraphics" operations. The suffix "Utils" seems to be superfluous.
  3. JTree.DynamicUtilTreeNode: also here the name "Util" does not contribute any valuable information. The name: "Decorator" would probably be more appropriate.
  4. SwingUtilities: a kitchen sink for Swing functionality. The methods for asynchronous UI updates: invokeLater or invokeAndWait are probably the most popular methods.
  5. SynthGraphicsUtils: a kitchen sink for Swing's skinnable look and feel. "Utils" also seems to be superfluos. Just "SynthGraphics" is shorter.
  6. Util: a kitchen sink of CORBA functionality. Comes with the most "interesting" JavaDoc: "Provides utility methods that can be used by stubs and ties to perform common operations."
  7. UtilDelegate: it delegates to the Util above.
  8. Utilities from Swing. The worst possible name for a class. The JavaDoc says: "A collection of methods to deal with various text related activities." I guess "Text" would be a better name.

See you at Java EE Workshops at Munich Airport, Terminal 2 or Virtual Dedicated Workshops / consulting. Is Munich's airport too far? Learn from home: airhacks.io.


Real World Java EE Workshops [Airport Munich]>

Geertjan's Blog - November 20, 2016 10:54 AM
React.js Calculator in Oracle JET

Using the techniques discussed here and here, you can integrate a pretty cool React calculator component into your Oracle JET application. By default, this is how it looks in the page:

When hovered over, the calculator animates and is then displayed as follows:

Here's how I'm structuring JSX composites in my Oracle JET application:

Geertjan's Blog - November 19, 2016 11:22 AM
React.js and Oracle JET (Part 2)

Following on from part 1, the next step is to have support for React JSX in the context of our Oracle JET application. The RequireJS plugin below works perfectly in the context of Oracle JET applications, as outlined below:

https://github.com/podio/requirejs-react-jsx

To use the above in your Oracle JET applications:

  1. Include the above plugin in "bower.json": "requirejs-react-jsx": "1.0.2"

  2. Add the following to the bootstrap file (i.e., main.js) paths directive:
        'babel': 'libs/requirejs-react-jsx/babel-5.8.34.min',
        'jsx': 'libs/requirejs-react-jsx/jsx'
    
  3. Create a file named "app.jsx", e.g., in a folder named "components", with this content, i.e., this defines a simple React component in a JSX file:
    define(function (require) {
        var React = require('react');
        var ReactDOM = require('react-dom');
        function App() {
            this.HelloWorld = React.createClass({
                render: function () {
                    return (
                            <div>
                                <h1>Hello, React!!!</h1>
                            </div>
                            );
                }
            });
        }
        App.prototype.init = function () {
            ReactDOM.render(
                <this.HelloWorld />,
                document.getElementById('root')
            );
        };
        return App;
    });
  4. Now, let's use the above React component in one of our Oracle JET modules:
    define(['ojs/ojcore', 'knockout', 'jsx!components/app'],
        function (oj, ko, App) {
            function HomeViewModel() {
                var self = this;
                self.handleAttached = function (info) {
                    var app = new App();
                    app.init();
                };
            }
            return new HomeViewModel();
        }
    );
    
  5. Finally, let's render the view, i.e., this is the "home.html" for the above "home.js":
    <div id="root"></div>

That's it, the first React component expressed in JSX in an Oracle JET application.

Here's a variation whereby you use a property in your JSX component, where the value changes based on a timer:

define(function (require) {
    var React = require('react');
    var ReactDOM = require('react-dom');
    var messages = ['Hello, World', 'Hello, Planet', 'Hello, Universe'];
    function App() {
        this.Greeting = React.createClass({
            render: function () {
                return (
                        <p>{this.props.message}</p>
                       )
            }
        });
    }
    App.prototype.init = function () {
        this.repeat();
    };
    App.prototype.repeat = function () {
        var ctx = this;
        var randomMessage = messages[Math.floor((Math.random() * 3))];
        ReactDOM.render(
                <this.Greeting message={randomMessage}/>,
                document.getElementById('root')
                );
        setTimeout(function(){ctx.repeat()}, 1000);
    };
    return App;

References: 

https://www.sitepoint.com/getting-started-react-jsx/

http://stackoverflow.com/questions/3264739/image-change-every-30-seconds-loop

NetBeans – Michael's blog - November 18, 2016 05:47 AM
JDK 10 project created

Although JDK 9 isn’t available yet, Mark Reinhold announced the JDK 10 being created. Subscription lists are available [1]. Hopefully this is an indicator, that JDK 9 wont be postponed anymore. Definitely this will be the next challenge to keep NetBeans in sync with Java.   [1] http://mail.openjdk.java.net/mailman/listinfo/jdk10-dev

Geertjan's Blog - November 17, 2016 08:00 AM
React.js and Oracle JET (Part 1)

Here is a fantastic small example that works perfectly, showing how to combine React with Require:

http://remarkablemark.org/blog/2016/09/24/react-requirejs-amd/

Let's take that and integrate it into an Oracle JET module.

  1. Include in Bower dependencies: "react": "15.3.2"

  2. Include in "paths" in bootstrap file, i.e., "main.js":
        'react': 'libs/react/react.min',
        'react-dom': 'libs/react/react-dom.min'
    
  3. In your viewModel:
    define(['ojs/ojcore', 'knockout', 'jquery', 'react', 'react-dom'],
     function(oj, ko, $, React, ReactDOM) {
        function HomeViewModel() {
          var self = this;
          self.handleAttached = function(info) {
            ReactDOM.render(
                React.createElement('h1', {}, 'hello from react!'),
                document.getElementById('root')
            );
          };
        }
        return new HomeViewModel();
      }
    );
    
  4. In your view:
    <div id="root"></div>
And that's all. You'll see the message above in your page when you load it.

Geertjan's Blog - November 15, 2016 07:58 AM
Top 5 Features of Oracle Application Container Cloud

I asked Shaun Smith, product manager of Oracle Application Container Cloud (ACC), what he considers its top 5 features to be.

He responded with this list:

  1. Polyglot platform. Use the language of your choice. Today we have Java SE, Node.js, PHP, and will be adding support for Java EE WAR deployment, as well as Python and Ruby. We're open to supporting other languages if the demand is there.

  2. Open platform. Run anything. This is an ideal platform for running open source stacks and containers like Tomcat, Jetty, Express, etc.

  3. Elastic. Applications can be scaled in/out and up/down to meet demand. Auto-scaling is coming soon so that, based on metrics, scaling actions can be triggered.

  4. Integrated with Oracle Developer Cloud Service. Handy for end-to-end continuous integration, build, test, and deployment.

  5. Integrated with Oracle Public Cloud ecosystem. This combination is ideal for building cloud native (microservice style) applications that need messaging, storage, etc.

Also, Java SE Advanced is included, i.e., you're able to interact with Flight Recorder under the Admin tab.  Once there, you'll see "Recordings".  The help text explains what you can do. The best strategy in production is to turn on Flight Recorder in "continuous" mode so that it is recording all the time, keeping a  user-specified amount of data/minutes of data. Then, in ACCS, one can trigger the dump of this data if any anomalous behavior is detected. From ACCS, you can download Flight Recorder data dumps and open in Mission Control on your desktop.

Watch Shaun in action here, where he provides a really great overview of the key features of ACC:

Geertjan's Blog - November 14, 2016 08:52 AM
Updates to Oracle JET MOOC

Before JavaOne/OpenWorld this year, we ran the first session of the Oracle JET MOOC (massive open on-line course). The aim was to prepare a large number of developers all at the same time about enterprise JavaScript in the context of Oracle JET, i.e., Oracle's free and open source JavaScript platform. The MOOC is on-line, self paced, three weeks, and focused on 10 YouTube clips per week for three weeks, with many homework tasks, quizzes, and a certificate of completion at the end. We ran the second session after JavaOne/OpenWorld and have started the third session today. In the process, thousands of developers have been introducing themselves to Oracle JET.

Since the time when we put the MOOC together in August, quite a few changes have taken place and we've tried to update some of the parts of the MOOC as a result. If we were to be really thorough about it, we'd need to re-record absolutely every part, which is not really doable. So, here's an overview of all the changes and where parts of the MOOC are impacted.

  • Oracle JET Releases. Oracle JET 2.1.0 and Oracle JET 2.2.0. When we put the MOOC together, Oracle JET was at version 2.0.2. In the meantime, both 2.1.0 and 2.2.0 have been released. Read about 2.1.0 here and about 2.2.0 here. To ensure that the latest version of Oracle JET is always downloaded via "bower.json", we've changed the hardcode "2.0.2" in the GitHub samples to "latest", which will mean that in some cases you'll see different libraries and different versions of libraries in the YouTube clips than you'll see in your own code when working with Oracle JET templates.

  • Composite Component Architecture. The biggest impact of the above releases on the MOOC is the introduction of the Composite Component Architecture introduced in Oracle JET 2.1.0. Read about there here in the Oracle JET Cookbook. That topic was already mentioned in the MOOC, in Lesson 3, Part 1, where we look at integration with 3rd party components. However, the code sample for that part has been updated to include all the code samples from the Cookbook dealing with composite components. Go here to look at that code sample.

  • Oracle JET Templates. A big impact on the MOOC is that the "Oracle JET QuickStart Basic" wizard in NetBeans IDE now uses the "navdrawer" template. Read about that here. Some parts of the MOOC have been updated so that, especially at the start of the MOOC, you're not confused about the difference in the code you'll see being generated when you work through the tasks and the code you'll see in the YouTube clips. In Lesson 1, part 1, 7, 8, and 9 have all been reworked a bit, so that you see "navdrawer" code in the YouTube clips, in most cases. However, the code on GitHub continues to use the earlier templates and so on, so that, if you want to have the old structure and so on, in case you want that for reference or to understand something you're seeing in the YouTube clips, just use the code in the GitHub repos.

  • NetBeans IDE 8.2. NetBeans IDE itself has seen a new release since the initial release of the MOOC. In most of the MOOC, NetBeans IDE 8.1 is used, though in some of the updated parts, the latest release, which is NetBeans IDE 8.2 is used. The only difference is that in NetBeans IDE 8.2, you do NOT need to install the Oracle JET Support plugin, since that is now a standard part of NetBeans IDE. If you are using NetBeans IDE 8.2, do NOT go to the Plugin Manager and do NOT search for the Oracle JET Support plugin. Instead, simply use the "Oracle JET QuickStart Basic" template in "Samples | HTML5/JavaScript", which you will immediately find to be available.

  • Hybrid Oracle JET Generator for NetBeans IDE. The generator in NetBeans IDE for hybrid mobile applications, which is used in Lesson 2, Part 10, has been rewritten. That part of the MOOC will be updated during this week. Read about the changed generator here.

  • Samples on GitHub. There are several new and updated samples in the Oracle JET MOOC GitHub repository. For example, Part-001 now contains all the code shown in the related YouTube clip, Part-012 contains a lot more data visualization samples, including usage of ojThematicMap, Part-014 contains the complete MovieFactory sample, Part-021 contains all the composite components from the Oracle JET Cookbook, and Part-022 includes samples for integrating with the Application Container Cloud.
Some other parts of the Oracle JET MOOC may be changed/updated during the coming weeks, though the above points are the main areas where the differences lie between the original MOOC as published in August and the current status of Oracle JET and the MOOC itself.

Geertjan's Blog - November 13, 2016 05:49 PM
Understanding the Enterprise JavaScript Landscape

Here's a recording (go to it directly on Vimeo here) of a session I did last week in Malmo, Sweden, at Oredev, all about the relevance of the JavaScript ecosystem for modern enterprise applications.

Get started with Oracle JET, i.e., Oracle's JavaScript enterprise platform, for free in a free three week on-line course here.

Geertjan's Blog - November 10, 2016 01:15 PM
Understanding Oracle's JavaScript Platform

Here's a recording (go to it directly on Vimeo here) of a session I did yesterday here in Malmo, Sweden, at Oredev, all about the requirements for enterprise JavaScript and Oracle's free and open source solutions for this space.

Get started with all of this yourself for free in a free three week on-line course here.

Geertjan's Blog - November 08, 2016 11:41 PM
Conversations with Cab Drivers

Malmo, Sweden, November 2016

San Francisco, USA, October 2016

Geertjan's Blog - November 07, 2016 10:37 AM
Join NetBeans on Slack: https://netbeans.signup.team

One of the coolest recent developments in the NetBeans ecosystem is the establishment of the NetBeans Slack channel. We've only got this going over the past few weeks and there's a few hundred already registered and active.

What's the big deal and what's so great about Slack? Well, to me, and to how I'm using it, is that I see it as a modernized version of IRC, with the benefit of direct and quick interaction, e.g., I was holding off on publishing the new release of the One Click Open Sesame plugin because I wasn't completely sure about what new features Chris and Benno had implemented and so I quickly wrote back and forth with Chris on Slack and very quickly had my questions cleared up, rather than e-mailing back and forth for a week or two before getting the story straight.

So, want quick answers to your questions, want to resolve something without too much hassle? Join the NetBeans Slack channels and, of course, the more that join the more useful it will be since there'll be more knowledge going around.

Go here to get started, i.e., simply enter your e-mail address and you're good to go:

https://netbeans.signup.team/

And this is what the UI looks like, for me: 

Nice and neat and efficient. Thanks Wade and Chris and others for working on this and making this already a big success with the potential for much more! 

Geertjan's Blog - November 05, 2016 12:39 PM
No More Double-Clicking To Open Files In NetBeans!

Probably to most NetBeans users, the need to double-click a file to open it has become part of your DNA.

However, consider the thought of not needing to double-click anymore. Simply select a file and it opens. That's what the "One Click Open Sesame" plugin aims to achieve for you:

http://plugins.netbeans.org/plugin/53723/one-click-open-sesame

The project was started some time ago here:

https://github.com/GeertjanWielenga/OneClickOpenSesame

Chris Lenz (@Chrizzly42) and Benno Markiewicz (@benM4) in Leipzig worked on it quite a bit over the past weeks and now usability has improved significantly:

  • The opened file does not get the focus anymore. Instead, focus stays back in the view where the click came from (Projects window, Files window, or Favorites window). This gives you the benefit that you can navigate through your view with your arrow keys and the focus will not change to the file that opens.

  • A fixed delay is added, of about 400ms, while in the next version the aim is to make it configurable, so that you can navigate through the view with your arrow keys and files don't open instantly and only after the specified delay.

  • An open document is reused while navigating through the view. If you set the focus to an open document and go back to the view, a new document will be created.

Awesome and I am using this constantly now. Well, since yesterday when I tried it out, and it's really nice. If you encounter any issues, go to the GitHub location above and report them!

Many thanks to Benno and Chris!

Geertjan's Blog - November 04, 2016 10:58 AM
Oracle JET: Where Is My Home?

Since the past few days, if you've been creating Oracle JET applications via the "Oracle JET QuickStart Basic" template, i.e., in NetBeans IDE via the wizard below...

...you might have been asking yourself: "Where is my home?" I.e., look below, there's no "home" module, that is, no "home.js" and no "home.html":

Not to worry, at all! What's happened is that we're now using the "navdrawer" template for the "Oracle JET QuickStart Basic" wizard, so that you end up with the file structure shown above, which looks as follows when opened in the browser:

The template is a bit different to how it used to be, with "home" and "library" and "performance" etc, though the content and underlying architecture is the same. Just a different layout, different modules, etc, not a different architecture, at all.

Essentially, the "dashboard" module is now the new "home" module, when you see references to "home" in Oracle JET tutorials and so on, just use the "dashboard" module instead.

NetBeans – Praxis LIVE - November 03, 2016 07:31 PM
Praxis LIVE v3 : Cyber-physical coding on the JVM

A few weeks ago I had the joy of presenting a short paper on Praxis LIVE at the International Conference on Live Coding at McMaster University in Hamilton, Canada. While acting as an introduction to Praxis LIVE, the paper covered … Continue reading

Geertjan's Blog - November 02, 2016 10:28 AM
Generator for Hybrid Oracle JET Applications

Thanks to a lot of helpful feedback from my colleague Graeme Mawson, I updated the NetBeans plugin that provides tooling for hybrid mobile development with Oracle JET. 

Go here to get it:

http://plugins.netbeans.org/plugin/64070/yooraclejet

Now, instead of multiple different wizards, each for a different Oracle JET template, and each for a different mobile platform, everything is now integrated into one single wizard named "Hybrid Oracle JET Application":

And here you see the next step of the wizard above, with all the options available in a single panel, plus a helpful preview at the end to show you the command you have constructed via the UI elements:

Now everything is integrated into a single wizard, as you can see.

The source code is here, pull requests are welcome:

https://github.com/GeertjanWielenga/YoOracleJET

APIDesign - Blogs - October 29, 2016 10:16 AM
CleanCode at OracleLabs

This is how we write CleanCode! At GeeCONPrague 2016 all OracleLabs speakers ware our classical outfit. The claim was that it helped us write CleanCode:

--JaroslavTulach 10:16, 29 October 2016 (UTC)