JavaOne Highlights for Tuesday

Going Wearable: Java, Raspberry Pi, and Cool Peripherals 8:30 AM - 10:30 AM - Hilton - Franciscan A/B Adopt-a-JSR for Java EE 7 and Java EE 8 11:00 AM - 12:00 PM - Parc 55 - Powell I/II Lambda Q&A Panel 12:30 PM - 1:30 PM - Hilton - Yosemite B/C Ask the JDK Architects, Part 1 4:00 PM - 5:00 PM - Hilton - Imperial Ballroom A The Modular Java Platform and Project Jigsaw Q&A 7:00 PM - 7:45 PM - Parc 55 - Cyril Magnin II/III

Posted by on 30 September 2014 | 7:43 pm

JavaOne Highlights for Monday

Java EE 7 Soup to Nuts 8:30 AM - 10:30 AM - Parc 55 - Market St Securing Java: Track Opening Presentation 11:00 AM - 12:00PM - Hilton - Golden Gate 6/7/8 Practical Guide to Making Your Home Smart with Java ME Embedded 12:30 PM - 1:30 PM - Parc 55 - Powell I/II What Every Java Programmer Should Know About Floating-Point Arithmetic 2:30 PM - 3:30 PM - Hilton - Imperial Ballroom A Coding for Desktop and Mobile with HTML5 and Java EE 7 2:30 PM - 3:30 PM - Hilton - Continental Ballroom 6 Driving the Java Carputer Farther and Faster 5:30 PM - 6:30 PM - Hilton - Continental Ballroom 4

Posted by on 29 September 2014 | 3:09 pm

A Geeky Script to Speed up Your App Development

It’s been a while since I’ve featured a more technically focused post on this blog, so I’ll try to remedy this today. One of the things that became obvious fairly quickly when we released Magnolia 5 in summer 2013 was that most users, when creating custom apps, create so called Content Apps. In other words, and not so surprisingly, people still use Magnolia as a content management system. This is good, and it’s what we predicted would happen. That’s why we made it very easy to build such apps in Magnolia. What is a content app? Before we go into my post, let me quote our documentation to give those of you who don’t know what a content app is a chance to catch up. “Content app is a specialized app type that manages custom data sets. The content app provides a user interface that consists of a browser subapp and a detail subapp. Content apps make it easy to organize items such as contacts or products. Many native Magnolia 5 apps such as Pages and Contacts are content apps. Because this app style is used often, the framework provides convenience classes to make building a content app faster.” And, if you’ve never done it, here’s a tutorial to create your first app: http://documentation.magnolia-cms.com/display/DOCS/My+first+content+app On beginners’ mistakes Nearly in all of my demos, I would show some kind of content app, sometimes even creating it on the fly. In workshops, developers would often write their first content app right then and there. While you can certainly build the app fast and easily, and while it’s cool that you can configure all UI elements quickly, there are some pains involved - or, to put it differently - it’s easy to make mistakes when configuring the app (like creating subnodes at wrong levels or with incorrect node types, or making typos in names). Consequently, multiple people have expressed plans to write an app would allow you to create new apps by simply filling in a form, or by going through some kind of wizard asking you what to do. I’m still hopeful that one day there will be such an app (hint, hint - community members!) Simplifying the app building process While I’m waiting for that beautiful app to be created, I’ll give you my intermediate solution to the issue (yep, I’m the kind of guy who still likes to write code in VI or similar kinds of IDEs). So what you get below is not a nice app, but instead a few hundred lines of groovy script that will create an app for you. If you lack imagination like me, you can just specify the display name for your app and let the script derive all the rest. If you are bit more decisive, you can force it to use certain other names for workspace, item name, node type, etc. And if you really want to make yourself heard, you can rewrite all the labels, add extra actions or remove existing ones … just like if you were reconfiguring an app via Admin Central (which of course you can still do). To prove how easy it is to use, it took me all of 30 seconds to create the following bunch of apps and yes, they all work well enough. The only thing I ask of you is this - if you find a bug in the script or if you improve it in any way, please contribute the code back so everyone can benefit from it. And without further delays: Script to build your Magnolia Content App A few words of warning Just like everything else, though, even this script is not without caveats. For it to work properly, you need the following improvements installed locally. Jira Issue to allow RepositoryManager to create workspace on the fly Jira Issue for additional Ops for NodeBuilder Jira Issue for inclusion of the script in Magnolia out of the box If you can’t or don’t want to apply patches for issues above, but still want to run the script right now: comment out the part that registers workspace at the end of the script (there’s a comment explaining which part it is) and register the workspace via the module descriptor as usual. Replace getOrAddNode() nodes in the script with getNode() or addNode() operations based on your existing module structure. AttachmentSize janpost.jpg201.87 KB

Posted by on 29 September 2014 | 1:06 am

JavaOne 2014 Day Zero Notes

I estimate that this is my 15th or 16th JavaOne. I started in 1998 or 1999 and missed 2003 due to the birth of my first son. Aside from that, I haven't missed one since. I consider myself very blessed to have taken a small part in such a long and fun ride. To add blessing on top of blessing, this is the fourh JavaOne at which I have had the honor to teach a class at Java University. My good friend Oliver Szymanski and I repeated our class from last year, updated with new content. We had 16 students, and they were fully engaged, learning about JSON, WebSocket, JSF and HTML5. After the class, which ran from 09:00 - 16:00, Ollie and I took in the Oracle OpenWorld Keynote and then headed over to the GlassFish party at ThirstyBear. This event has stood the test of time, becoming the one time of the year when the leading lights of the Java Community come together to compare notes and set plans for the big week ahead. The real action starts tomorrow. My agenda includes giving my Servlet 4.0 talk with Shing-Wai Chan and my JSF 2.3 talk with Manfred Riem, Ian Hlavats and Kito Mann, in addition to the requsite booth duty from 09:30 - 12:00.

Posted by on 28 September 2014 | 7:39 pm

Java arrays in depth

Arrays in Java are a particular type of data structure that comprise of a fixed sized linear sequence conceptually similar in functionality to generic containers, a type from which they are easily distinguished by their characteristic ability to hold primitive as well as non-primitive types. Arrays also provide efficient random access to stored sequences through the use of an index and the Java compiler undertakes type checking to protect against unexpected types. You can create arrays either explicitly using the new expression or implicitly by means of some special initialisation syntax. It is worth noting that arrays are actual types and when you create an array, a real object is created on the heap. The array identifier is a reference to the actual object that holds references to the other objects. Furthermore, arrays are easily distinguishable from other types by their use of angle brackets [] and are known to hold primitive values directly while holding references for non-primitive arrays. For example to explicitly create an array of ints to hold a list of numbers, you could write the following expression like so:- int[] numList = new int[10]; The identifier numList holds a reference to an actual object that has space for up to ten references. It is worth mention that Java automatically initialises primitive arrays to zero and non-primitive arrays to null such that if you were to make a print of the above numList array you will be presented with zero values numbering 10. The most common way to initialise an array is within a for loop like so:- package arrays.java; import java.util.Arrays;import java.util.Random; public class InitialiseArray {     static Random random = new Random();     public static int[]  arrayInit(int[] array) {         for(int i = 0; i < array.length; i++)             array[i] = random.nextInt(array.length);         return array;     }     public static void main(String[] args) {         int[] numList = new int[10];         System.out.println(Arrays.toString(arrayInit(numList)));     }}/** Output[3, 7, 2, 7, 8, 3, 3, 0, 9, 0]**/ Here, the arrayInit() method accepts an array of ints and initialises it with int values in a for loop using a random generator. The public interface of an array consists only of a length method that returns the number of elements within the array or more precisely, the size of the array. Arrays also provide you the means to return a more complex object from a method as opposed to single valued objects. It is also possible to create arrays implicitly by combining creation and initialisation into one step like so:- String[] greeting = { new String("Hello"), new String("Goodbye") };  //Aggregate initialisationint[] numbers = new int[]{ 4, 7, 10, 3, 5, 9, 14, 18, 30, 8,  };          //Dynamic aggregate initialisation Multidimensional arrays Multidimensional arrays are arrays that have a multiple dimensions allowing the programmer to make use of a more complex data structure. To declare a multidimensional array you only need supply additional angle brackets to represent the number of dimensions. For instance, to create a two and three dimensional array of int, you would simply append the desired number of angle brackets:- int[][] ListA = new int[1][3];       // 2-D arrayint[][][] Listb = new int[2][3][2];  // 3-D array The idea is that each angle bracket represents a single dimension and in theory you can have as many of those as you want, though I suspect at a certain point the level of complexity might become somewhat intractable. For instance the 3-D array above can be read to mean the first dimension consists of two elements, each of which contain three elements in the second dimension. In the third dimension, each of these three elements in turn comprise of a further two elements. If you are new to multidimensional arrays, it is easy become confused. Initialising a multidimentional array with values in a for loop requires a certain level of finesse as it is not quite as straightforward a a 1-D array. The following code demonstrates how to initialises a 3-D array using nested loops:- package arrays.java; import java.util.Arrays;import java.util.Random; public class Initialising3DArray {     static double[][][] a;     static void init3DArray(int size, double start, double end) {         Random rand = new Random(12);         a = new double[rand.nextInt(size)][][];          if(start > end)             throw new IllegalArgumentException("Start range should be less than end Range"); // Unchecked exception!         double value = end - start;         for(int i = 0; i < a.length; i++) {             a[i] = new double[rand.nextInt(size)][];             for(int j = 0; j < a[i].length; j++) {                 a[i][j] = new double[rand.nextInt(size)];                 for(int k = 0; k < a[i][j].length; k++)                     a[i][j][k] = rand.nextInt((int)value);             }         }     }     static void print() {         System.out.println(Arrays.deepToString(a));     }     public static void main(String[] args) {         init3DArray(8,5,9);         print();     }} In this example, a 3-D array of double is initialised with a random length first element. The second and third elements are initialised in a for and nested for loop respectively, again using random values. The result is a 'ragged' array where each vector in the array is of a different length. The final nested loop is used to add values into all elements of the array. Notice how Java automatically promotes int values to double expected by the init3DArray() method. The same effect can be observed in the last line of the method where the array is initialised with random values. In general, when two primitives are combined in a computation, Java will promote the smaller primitive to the same type as the larger primitive. Arrays and generics Because of erasure it is not possible to instantiate an array of parameterised types because arrays need to know about types to enforce type safety. You can nevertheless create an array of generic types, by creating an array of non-generified type and then casting back to an array of generic type:- package arrays.java; class GenericType {} public class ArrayOfGenerics {     public static void main(String[] args) {         GenericType[] nonGenerifiedArray = new GenericType[6];  // "Unchecked" warning for array of generics - ok         GenericType<Integer>[] generifiedArray = (GenericType<Integer>[])nonGenerifiedArray;         for(int i = 0; i < generifiedArray.length; i++)             generifiedArray[i] = new GenericType<Integer>();     // Array of generics     }} Note that an array of generics will only hold other arrays of other generics and this is not the same thing as an array of parameterised type which is impossible because of the effects of erasure. However, you may parameterise the type of an array within a class or method:- package arrays.java; public class ParameterisedArrayTypes<T> {      public T[] classParameterisedType(T[] type) {         return type;     }     static <E> E[] methodParameterisedType(E[] type) {         return type;     }     public static void main(String[] args) {         ParameterisedArrayTypes<Integer> para = new ParameterisedArrayTypes<Integer>();         Integer[] iArray = para.classParameterisedType(new Integer[5]);         Double[] dArray = methodParameterisedType(new Double[5]);         String[] sArray = methodParameterisedType(new String[10]);     }} The above example has two methods. The first method uses a class parameter to parameterise the type of the array, while the second method uses a method parameter to achieve the same effect. The advantage of a parameterised method is that it can be used independently of and in parallel with a parameterised class. Generating data Arrays are only as useful as how quickly and efficiently one might be able to populate them with data, perhaps for testing purposes. There are a number of ways to quickly generate data for arrays one of the most common of which is the overloaded fill() method in the Arrays class, which simply copies a value to each element in an array:- package arrays.java; import java.util.Arrays; class Start {     public static void main(String[] args) {         int[] a = new int[args.length];         Arrays.fill(a, 20);         System.out.println(Arrays.toString(a));     }}public class FillingArrays {     public static void main(String[] args) {         Start.main(new String[8]);     }}/** Output[20, 20, 20, 20, 20, 20, 20, 20]**/ The fill() method is overloaded for all primitive types as well as objects. Unfortunately it is severely limited because it can only fill an array with one value when most times you might need a range of values for your tests to come anywhere near realistic. One way to overcome this limitation is to use an object based data generator. By assigning responsibility for generating data to an interface, it becomes possible to share that functionality among a number of types. For instance, we might define an interface of a parameterised type that can be used to generate any type. We can call this Generator:- package arrays.java;public interface Generator<T> { T next(); } The interface has only one method next() that must be implemented by any subtype implementing this interface. It is now possible to quickly generate a variety of objects that can be used to initialise arrays For instance to create an array of unique string objects, we could implement a string generator like so:- package arrays.java; import java.util.Random; public class StringGenerator implements Generator<String> {     private int length = 8;     Random random = new Random();     char[] pickOne = ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ").toCharArray();     public String next() {         char[] string = new char[length];         for(int i = 0; i < length; i++)             string[i] =  pickOne[random.nextInt(pickOne.length)];         return new String(string);     }   public static void main(String[] args) {         StringGenerator gen = new StringGenerator();         String[] array = new String[10];         for(int i = 0; i < array.length; i++)             array[i] = gen.next();         System.out.println(Arrays.toString(array));     }}/** output[grpvpNAr, nnbEbQHW, lQJxvspb, ObCuoabu, lUkcPEhY, KXIpGxbj, MsdcESuf, AtyDyITF, HIbWUszp, HfbsstMc]**/ The StringGeneratorclass implements the next() method within which a pseudo- randomised algorithm is used to generate unique string objects that are then used in the main() to initialise a String array. As opposed to implementing a generator for every object you might want to create, it might be more efficient to create a generic method capable of creating an array from any type:- package arrays.java; import java.lang.reflect.Array;import java.util.Arrays; public class ArrayGenerator {     static  String[] stringArray;     static Integer[] intArray;     private static int size = 10;     @SuppressWarnings("unchecked")     public static <T> T[] generateArray(Class<T> type) throws InstantiationException, IllegalAccessException {         return (T[])Array.newInstance(type, size);      }     public static int length() {         return size;     }     public static void main(String[] args) {         StringGenerator gen = new StringGenerator();         try {             stringArray = generateArray(String.class);             intArray = generateArray(Integer.class);         } catch (InstantiationException | IllegalAccessException e) {             e.printStackTrace();         }         for(int i = 0; i < ArrayGenerator.length(); i++) {             stringArray[i] = gen.next();             intArray[i] = i;         }         System.out.println(Arrays.toString(stringArray));         System.out.println(Arrays.toString(intArray));     }}/** Output[AwOYakKc, UgciOWsH, ERRgKqqI, gmrzNtRc, TgzbxYAN, HiudPPOo, BtEMuHuL, yybvAeph, vVsriPrq, yyNKkMJd][0, 1, 2, 3, 4, 5, 6, 7, 8, 9]**/ The parameterised method generateArray() uses reflection to create an array of specified type and size. The decision of whether to use generics or object generators to quickly generate test data for use with arrays will be one of personal choice and know-how. Array utilities The Arrays class in the java.util package has a number of methods for manipulating arrays like sorting and searching operations. It also has an overloaded equals() method for comparing primitive and non-primitive arrays. For any two arrays to be equal, they must possess the same number of elements and each element in one must be equivalent to the corresponding element in the other array on the basis of the equals() method for each element. package arrays.java; import java.lang.reflect.Array;import java.util.Arrays; public class ArrayEquality {     public static void main(String[] args) {         //Non-primitive arrays         Integer[] one = (Integer[])Array.newInstance(Integer.class, 4);         Integer[] two =  { new Integer(20), new Integer(20), new Integer(20), new Integer(20) };         Arrays.fill(one, 20);         System.out.println("1: " + Arrays.equals(one,two));         one[3] = 21;         System.out.println("2: " + Arrays.equals(one,two));          //Primitives arrays         double[] pOne = new double[4];         Arrays.fill(pOne, 5);         double[] pTwo = new double[5];         Arrays.fill(pTwo, 5);         System.out.println("4: " + Arrays.equals(pOne, pTwo));         double[] pThree = new double[] {new Double(5), new Double(5), new Double(5), new Double(5)};         System.out.println("5: " + Arrays.equals(pOne, pThree));     }}/** Output1: true2: false4: false5: true*/ In the main() two non-primitive arrays are created, first using reflection and the second is created implicitly. Both arrays have four elements and contain the number 20. The Arrays.equals() method agrees these two to be equivalent. When an element in one array is change, this is reflected in the array comparison. The equals() works the same way in an array of primitives The Arrays.sort() method allows you to sort through an array of elements that implement the Comparable interface or that has an associated Comparator:- The following code sorts through an array of ints and non primitive Strings package arrays.java; import java.lang.reflect.Array;import java.util.*;@SuppressWarnings("serial")class ArrayData<T> extends ArrayList<T> {     public ArrayData(Generator<T> generator, int size) {         for(int i = 0; i < size; i++)             add(generator.next());     }} public class AllSorts {     @SuppressWarnings("unchecked")     public static <T> T[] createArray(Class<T> aType, Generator<T> generator, int size) {         T[] array = (T[]) Array.newInstance(aType, size);         return new ArrayData<T>(generator, size).toArray(array);     }     public static void main(String[] args) {         Random generator = new Random();         int[] one = new int[8];         for(int i = 0; i < one.length; i++)             one[i] = generator.nextInt(200);         System.out.print("Before sort: " + Arrays.toString(one) + "\n");         Arrays.sort(one);         System.out.print("After sort: " + Arrays.toString(one) + "\n");         System.out.println();         String[] two = createArray(String.class, new StringGenerator(), 5);         System.out.print("Before sort: " + Arrays.toString(two) + "\n");         Arrays.sort(two);         System.out.print("After sort: " +  Arrays.toString(two) + "\n");         Arrays.sort(two, String.CASE_INSENSITIVE_ORDER);         System.out.print("Case sensitive order: " + Arrays.toString(two) + "\n");     }}/** OutputBefore sort: [194, 152, 65, 72, 175, 162, 23, 196]After sort: [23, 65, 72, 152, 162, 175, 194, 196] Before sort: [iFrPcQus, APvoBpaN, pJGKftOz, eVKaFVYz, pgOxbHCq]After sort: [APvoBpaN, eVKaFVYz, iFrPcQus, pJGKftOz, pgOxbHCq]Case sensitive order: [APvoBpaN, eVKaFVYz, iFrPcQus, pgOxbHCq, pJGKftOz]**// The static createArray() method returns an array of any type from an ArrayList by accepting a Class type, generator object and a size argument. Note the compiler uses it's autoboxing mechanism to represent the int primitive type as an Integer object on the heap, which as it happens implements the Comparable interface. The same is true of the String class. The final sort() method uses the CASE_INSENSITIVE_ORDER attribute of the String class to group strings together regardless of case. The Collections class provides a static reverseOrder() method that returns a Comparator that imposes the reverse of the natural ordering of a collection of objects that implement the Comparable interface:- package arrays.java; import java.util.Arrays;import java.util.Collections;import java.util.Random; public class TestReverseOrder {     static Random random = new Random();     static Generator<Integer> generator() {         return new Generator<Integer>() {             public Integer next() {                 return random.nextInt(200);             }         };     }     public static void main(String[] args) {         Generator<Integer> generator = generator();         Integer[] reversed = AllSorts.array(Integer.class, generator, 20);         Arrays.sort(reversed);         System.out.println("Sorted array: " + Arrays.toString(reversed));         Arrays.sort(reversed, Collections.reverseOrder());         System.out.println("Reversed array: " + Arrays.toString(reversed));     }}/** OutputSorted array: [13, 19, 32, 36, 43, 48, 68, 74, 75, 89, 99, 121, 121, 146, 150, 155, 171, 173, 177, 183]Reversed array: [183, 177, 173, 171, 155, 150, 146, 121, 121, 99, 89, 75, 74, 68, 48, 43, 36, 32, 19, 13]**/ In this example, the generator() method uses an anonymous class to return an integer generator. In the main(), the second version of the sort() method sorts the specified array using the supplied Comparator object. The Arrays class has quite a number of other useful methods that are worth checking out, for instance the overloaded binarySearch(). method can be used to search through a specified array for a specific value. The java.lang.reflect.Array API is another useful class that provides methods to dynamically create and access arrays. An example of this is the newInstance() method which is used in several previous examples.

Posted by on 27 September 2014 | 5:23 am

Glassfish 4.1 is available!

For all you Glassfish users out there Glassfish 4.1 has been released. See https://blogs.oracle.com/java/entry/glassfish_server_open_source_edition for more information Enjoy!

Posted by on 26 September 2014 | 4:54 am

MVC 1.0 JSR is on its way!

The ballot for MVC 1.0 has passed and we have approval. So now it is time to move forward with EG formation and from there it is off to work! Since we are a new JSR we do not have all our infrastructure setup yet. Please be patient we will get everything setup soon. Note as I am attending JavaOne it might not happen until after JavaOne ;) Enjoy!

Posted by on 25 September 2014 | 2:07 am

My new book "RESTful Java Patterns and Best Practices"

RESTful Java Patterns and Best Practices is the second book which I have worked on and is recently published. Overview The convergence of social networking, cloud computing, and era of mobile applications creates a generation of emerging technologies that allow different networked devices to communicate with each other over the Internet. As the technology landscape evolves, today’s applications are built on the notion of producing and consuming APIs This API based architecture enables agile development, easier adoption and prevalence, scale and integration with applications within and outside the enterprise. The advent of mobile applications calls for a stricter delineated client-server model. Companies building applications on IOS and Android platform can consume the REST based API and extend and deepen their reach by combining data from multiple platforms because of the API centric REST based architecture. The widespread adoption of REST and JSON opens up the possibilities of applications incorporating and leveraging functionality from other applications as needed. Popularity of REST is mainly because it enables building lightweight simple, cost-effective modular interfaces, which can be consumed by a variety of clients. One of the most important considerations for the apps is dealing with security. The developers building apps should not be concerned with the user's credentials. .The clients can be acting on behalf of other users and must be authorized to perform actions for them without the user having to share his credentials for username and password.This is where the OAuth 2.0 specification comes into picture. Another important aspect to consider when building distributed applications is traceability, which will involve logging the data related to requests for debugging purposes in an environment encompassing multiple micro services, which can be geographically distributed and deal with thousands of requests. Similarly caching, rate-limiting, validation and exception handling as well as asynchronous processing are essential elements to be considered when building RESTful services. Micro services based architecture comprises of breaking a monolithic application into fine grained services which can provide benefits of simplicity, separation of concerns, isolation of problems, independent scale up and scale down thus providing the foundation for a resilient architecture. RESTful Java Patterns and Best Practices aims to cover all these topics in detail with code samples using JAX-RS along with best practices and case studies from the ubiquitous platforms like Facebook, GitHub, Twitter, PayPal etc. What this book will cover How to build RESTful web services using JAX-RS 2.0 API Gain insights into techniques related to versioning, error handling, response codes in REST Clarify advanced topics related to SAML and OAUTH 2.0, similarities between SAML and 3-legged OAuth as well as best practices for OAuth Discuss caching techniques, validation, rate-limiting, asynchronous operations and other best practices to improve application responsiveness Review best practices for logging, pagination, documentation, testing of RESTful services. Show how highly available cloud applications tend to move to a networked component model where applications are decomposed into micro services, which can be deployed and scaled independently Cover the future of REST and evolving standards along with case studies on how different enterprises use them Compare and contrast other technologies like WebHooks, WebSockets and Server-Sent Events for delivering real time data to clients Compare REST API from Twitter, GitHub, Facebook and others Who this book is for RESTful Java Patterns and best practices, is a practical, hands-on guide that provides you with clear and pragmatic information to take advantage of the real power of RESTful services and gives you a good foundation for using them in your applications. The book is aimed at novice developers who want to gain insights in building RESTful services as well as advanced developers who want to delve into complicated topics. Approach A step-by-step approach to build complex RESTful services for the real world applications explained in a conversational and easy-to-follow style. Each topic is explained sequentially and scrupulously by building on ideas and discussions covered in previous chapters, thus tying the concepts neatly together . Follow @bhakti_mehta

Posted by on 25 September 2014 | 12:11 am

JSF 2.3 EG is on its way!

And we are on our way for JSF 2.3 now. The kick off email to the JSF 2.3 EG has been sent! You can see the publicly available announcement on the spec users list, see https://java.net/projects/javaserverfaces-spec-public/lists/users/archiv... Note that I will be trying to blog about additions to JSF 2.3 once they get added so we can have you all test them out. No hard promise though ;) Enjoy!

Posted by on 24 September 2014 | 9:33 am

JSF 2.3 has been approved

The ballot for JSF 2.3 has passed and we have approval. So now it is time to move forward with EG formation and from there it is off to work! How can you stay up to date to what is happening? 1. Subscribe to the spec users list, see https://java.net/projects/javaserverfaces-spec-public/lists and select the users@javaserverfaces-spec-public.java.net list 2. Keep track of the issues being resolved on the issue tracker, see https://java.net/jira/browse/JAVASERVERFACES_SPEC_PUBLIC 3. Try out our SNAPSHOT builds, see https://maven.java.net/content/repositories/snapshots/org/glassfish/java... and look for 2.3.0-mXX-SNAPSHOT builds 4. Join the Mojarra users list if you have more questions specific to trying out the 2.3 runtime Enjoy!

Posted by on 23 September 2014 | 2:08 pm