Feed aggregator

The JVM Architecture Explained

Javalobby Syndicated Feed - Fri, 02-Sep-16 02:31

Every Java developer knows that byte code will be executed by JRE (Java Runtime Environment). But many doesn't know the fact that JRE is the implementation of Java Virtual Machine (JVM), which analyses the byte code, interprets the code, and executes it. It is very important as a developer that we should know the Architecture of the JVM, as it enables us to write code more efficiently. In this article we will learn more deeply about the JVM architecture in Java and the different components of the JVM.

What is the JVM?

A Virtual Machine is a software implementation of a physical machine. Java was developed with the concept of WORA (Write Once Run Anywhere), which runs on a VM. The compiler compiles the Java file into a Java .class file, then that .class file is input into the JVM, which Loads and executes the class file. Below is a diagram of the Architecture of the JVM.

Categories: Java

Java 8 — MinguoDate Examples

Javalobby Syndicated Feed - Fri, 02-Sep-16 02:31

This MinguoDate calendar system is primarily used in Taiwan (Republic of China)

 (ISO) 1912-01-01 = 1-01-01 (Minguo ROC) 

To convert the current date to the Minguo date, just subtracts the current year with number 1911, for example

Categories: Java

Vertical vs. Horizontal Decomposition of Responsibility

Javalobby Syndicated Feed - Fri, 02-Sep-16 00:31

Objects responsible for too many things are a problem. Because their complexity is high, they are difficult to maintain and extend. Decomposition of responsibility is what we do in order to break these overly complex objects into smaller ones. I see two types of this refactoring operation: vertical and horizontal. And I believe the former is better than the latter.

Once Upon a Time in America (1984) by Sergio LeoneOnce Upon a Time in America (1984) by Sergio Leone

Let's say this is our code (in Ruby):

Categories: Java

Beginners Guide to Functional Programming: Part 2

Javalobby Syndicated Feed - Thu, 01-Sep-16 22:31

This article is a continuation of part 1, where we introduced why we should even bother with functional programming in the first place. 

Quick Glossary of Terms

Mutable: You can set a variable again and again. Opposite of a constant. Mutable state means I can set the variable to something else later.

Categories: Java

PowerShell Decompiled: How do loops work?

Adam Driscoll's Blog - Thu, 01-Sep-16 11:48

In my quest to figure out why handles.ps1 was running very slowly when looping over the 3.4 million handles on my system, I started to realize that the loop structure itself was a lot slower than a language like C#. I know that PowerShell is compiled to an executable lambda statement when it meets particular criteria so I went to figure out what a loop looks like when it’s compiled. The aptly named Compiler class takes care of this. The Compiler class is invoked on ScriptBlocks to generate in-memory functions that are a representation of that block. The Compiler class is an implementation of a ICustomAstVisitor2 that is developed to “Visit” each type of expression in a block. Example of this are ForEachStatementAst and ReturnStatementAst.

While perusing the source code for the Compiler class you’ll come across a lot of Visit* methods. Each of these methods takes a particular part of the PowerShell AST and turns it into a LINQ Expression that can then be used to generate a executable lambda. Let’s look at what makes up a couple of the looping statements.

While Loops

While loop are the basis for a lot of other loops when you break down the Compiler class. The while loop is actually implemented by using several different labels and gotos to achieve loop functionality. At the top of the GenerateWhileLoop method, you’ll see a comment that defines the pseudo-code for a PowerShell while loop.

There are 3 different distinct labels. The LoopTop, BreakTarget and ContinueTarget. Gotos will jump to the various labels based on whether you use the continue or break keyword or move to the next iteration of the loop.

Given the loop: while($true) { }

The resulting output will be:

.Extension {
    .Block() {
        .Label
        .LabelTarget continue:;
        .Extension {
            .Default(System.Void)
        };
        .If (
            .Block() {
                .Default(System.Void);
                True
            }
        ) {
            .Try {
                .Block() {
                    .Call System.Management.Automation.PipelineOps.CheckForInterrupts($context);
                    .Block() {
                        .Default(System.Void)
                    };
                    .Goto continue { }
                }
            } .Catch (System.Management.Automation.BreakException $var1) {
                .If (
                    .Call $var1.MatchLabel("")
                ) {
                    .Break break { }
                } .Else {
                    .Rethrow
                }
            } .Catch (System.Management.Automation.ContinueException $var2) {
                .If (
                    .Call $var2.MatchLabel("")
                ) {
                    .Continue continue { }
                } .Else {
                    .Rethrow
                }
            }
        } .Else {
            .Default(System.Void)
        };
        .Label
        .LabelTarget break:
    }
}

ForEach Loops

ForEach loops are just a modification of the while loop. The comment in the Compiler class states the pseudo-code for a loop looks like this.

You can see that the ForEach is just turned into a while statement that uses the IEnumerable class to call MoveNext and Current to move through the collection.

Given the loop: foreach($x in $i) { }

The resulting output will be:

    .Try {
        .Block() {
            $old_foreach0 = .Call System.Management.Automation.VariableOps.GetVariableValue(
                .Constant(local:foreach),
                $context,
                (System.Management.Automation.Language.VariableExpressionAst)null);
            .Default(System.Void);
            $enumerable1 = .Call System.Management.Automation.VariableOps.GetVariableValue(
                .Constant(i),
                $context,
                .Constant($i));
            $foreach2 = .Extension {
                .Invoke (.Constant<System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Collections.IEnumerator]]>(System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Collections.IEnumerator]]).Target)(
                    .Constant<System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Collections.IEnumerator]]>(System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Collections.IEnumerator]]),
                    $enumerable1)
            };
.If (
                $foreach2 == null && $enumerable1 != null
            ) {
                $foreach2 = .Call (.NewArray System.Object[] {
                    (System.Object)$enumerable1
                }).GetEnumerator()
            } .Else {
                .Default(System.Void)
            };
            .Call System.Management.Automation.VariableOps.SetVariableValue(
                .Constant(local:foreach),
                (System.Object)$foreach2,
                $context,
                (System.Management.Automation.Language.AttributeAst[])null);
            .If ($foreach2 != null) {
                .Extension {
                    .Block() {
                        .Label
                        .LabelTarget continue:;
                        .Extension {
                            .Default(System.Void)
                        };
                        .If (
                            .Block() {
                                .Extension {
                                    .Block() {
                                        $funcContext._currentSequencePointIndex = 1;
                                        .If ($context._debuggingMode > 0) {
                                            .Call ($context._debugger).OnSequencePointHit($funcContext)
                                        } .Else {
                                            .Default(System.Void)
                                        };
                                    .Rethrow
                                }
                            } .Catch (System.Management.Automation.ContinueException $var2) {
                                .If (
                                    .Call $var2.MatchLabel("")
                                ) {
 .Continue continue { }
                                } .Else {
                                    .Rethrow
                                }
                            }
                        } .Else {
                            .Default(System.Void)
                        };
                        .Label
                        .LabelTarget break:
                    }
                }
            } .Else {
                .Default(System.Void)
            }
        }
    } .Finally {
        .Call System.Management.Automation.VariableOps.SetVariableValue(
            .Constant(local:foreach),
            $old_foreach0,
            $context,
            (System.Management.Automation.Language.AttributeAst[])null)
    }
}

For Loops

For loops are again a modification of the while loop but with the added control and condition of the iterator.

Given the loop: for($i = 0; $i -lt 10; $i++) { }

The resulting output will be:

.Block() {
    .Default(System.Void);
    .Call System.Management.Automation.VariableOps.SetVariableValue(
        .Constant(i),
        (System.Object)0,
        $context,
        (System.Management.Automation.Language.AttributeAst[])null)
}
.Block() {
    .Default(System.Void)
}
.Block(System.Object $var1) {
    $var1 = .Call System.Management.Automation.VariableOps.GetVariableValue(
        .Constant(i),
        $context,
        .Constant($i));
    .Call System.Management.Automation.VariableOps.SetVariableValue(
        .Constant(i),
        .Extension {
            .Invoke (.Constant<System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Object]]>(System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Object]]).Target)(
                .Constant<System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Object]]>(System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Object]]),
                $var1)
        },
        $context,
        (System.Management.Automation.Language.AttributeAst[])null);
    .If ($var1 == null) {
        (System.Object)0
    } .Else {
        $var1
    }
}
.Call System.Management.Automation.VariableOps.GetVariableValue(
    .Constant(i),
    $context,
    .Constant($i))
10
.Extension {
    .Invoke (.Constant<System.Runtime.CompilerServices.CallSite`1[System.Func`4[System.Runtime.CompilerServices.CallSite,System.Object,System.Int32,System.Object]]>(System.Runtime.CompilerServices.CallSite`1[System.Func`4[System.Runtime.CompilerServices.CallSite,System.Object,System.Int32,System.Object]]).Target)(
        .Constant<System.Runtime.CompilerServices.CallSite`1[System.Func`4[System.Runtime.CompilerServices.CallSite,System.Object,System.Int32,System.Object]]>(System.Runtime.CompilerServices.CallSite`1[System.Func`4[System.Runtime.CompilerServices.CallSite,System.Object,System.Int32,System.Object]]),
        .Call System.Management.Automation.VariableOps.GetVariableValue(
            .Constant(i),
            $context,
            .Constant($i)),
        10)
}
.Block() {
    .Block() {
        .Default(System.Void);
        .Call System.Management.Automation.VariableOps.SetVariableValue(
            .Constant(i),
            (System.Object)0,
            $context,
            (System.Management.Automation.Language.AttributeAst[])null)
    };
    .Extension {
 .Block() {
            .Label
            .LabelTarget looptop:;
            .Extension {
                .Default(System.Void)
            };
            .If (
                .Extension {
                    .Invoke (.Constant<System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Boolean]]>(System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Boolean]]).Target)(
                        .Constant<System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Boolean]]>(System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Boolean]]),
                        .Block() {
                            .Extension {
                                .Block() {
                                    $funcContext._currentSequencePointIndex = 2;
                                    .If ($context._debuggingMode > 0) {
                                        .Call ($context._debugger).OnSequencePointHit($funcContext)
                                    } .Else {
                                        .Default(System.Void)
                                    };
                                    .Default(System.Void)
                                }
                            };
  .Extension {
                                .Invoke (.Constant<System.Runtime.CompilerServices.CallSite`1[System.Func`4[System.Runtime.CompilerServices.CallSite,System.Object,System.Int32,System.Object]]>(System.Runtime.CompilerServices.CallSite`1[System.Func`4[System.Runtime.CompilerServices.CallSite,System.Object,System.Int32,System.Object]]).Target)(
                                    .Constant<System.Runtime.CompilerServices.CallSite`1[System.Func`4[System.Runtime.CompilerServices.CallSite,System.Object,System.Int32,System.Object]]>(System.Runtime.CompilerServices.CallSite`1[System.Func`4[System.Runtime.CompilerServices.CallSite,System.Object,System.Int32,System.Object]]),
                                    .Call System.Management.Automation.VariableOps.GetVariableValue(
                                        .Constant(i),
                                        $context,
                                        .Constant($i)),
                                    10)
                            }
                        })
                }
            ) {
                .Block() {
                    .Try {
                        .Block() {
                            .Call System.Management.Automation.PipelineOps.CheckForInterrupts($context);
                            .Block() {
                                .Default(System.Void)
                            }
                        }
                    } .Catch (System.Management.Automation.BreakException $var1) {
                        .If (
                            .Call $var1.MatchLabel("")
                        ) {
   .Break break { }
                        } .Else {
                            .Rethrow
                        }
                    } .Catch (System.Management.Automation.ContinueException $var2) {
                        .If (
                            .Call $var2.MatchLabel("")
                        ) {
                            .Continue continue { }
                        } .Else {
                            .Rethrow
                        }
                    };
                    .Label
                    .LabelTarget continue:;
                    .Extension {
                        .Block() {
                            $funcContext._currentSequencePointIndex = 1;
                            .If ($context._debuggingMode > 0) {
                                .Call ($context._debugger).OnSequencePointHit($funcContext)
                            } .Else {
                                .Default(System.Void)
                            };
                            .Default(System.Void)
                        }
                    };
                    .Block(System.Object $var3) {
                        $var3 = .Call System.Management.Automation.VariableOps.GetVariableValue(
                            .Constant(i),
                            $context,
  .Constant($i));
                        .Call System.Management.Automation.VariableOps.SetVariableValue(
                            .Constant(i),
                            .Extension {
                                .Invoke (.Constant<System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Object]]>(System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Object]]).Target)(
                                    .Constant<System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Object]]>(System.Runtime.CompilerServices.CallSite`1[System.Func`3[System.Runtime.CompilerServices.CallSite,System.Object,System.Object]]),
                                    $var3)
                            },
                            $context,
                            (System.Management.Automation.Language.AttributeAst[])null);
                        .If ($var3 == null) {
                            (System.Object)0
                        } .Else {
                            $var3
                        }
                    };
                    .Goto looptop { }
                }
            } .Else {
                .Default(System.Void)
            };
            .Label
            .LabelTarget break:
        }
    }
}

So there is a lot more going on when PowerShell is looping than when languages like C# are looping. Might be why my functions are a little slow. &#x1f609;

Categories: Powershell

OCI and DZone Present Grails Quickcast #5: Retrieving Runtime Config Values In Grails 3

Javalobby Syndicated Feed - Thu, 01-Sep-16 07:03

Today we bring you a new Grails Quickcast, where Grails co-founder Jeff Scott Brown highlights some of the great features of the Grails framework.  In less than 18 minutes, Jeff describes several techniques for retrieving configuration values at runtime and discusses the pros and cons of these different techniques. The Grails Quickcast series is brought to you from OCI and DZone.  

Grails leverages the “Convention Over Configuration” design paradigm, which functions to decrease the number of decisions that a developer using the framework is required to make without losing flexibility. This is one of the main reasons why Grails significantly increases developer productivity!

Categories: Java

Last Call and Some Results for DZone Joint Community Survey on Java EE 8

Javalobby Syndicated Feed - Thu, 01-Sep-16 06:58

The joint community survey on Java EE 8 by the Java EE Guardians and DZone ends September 7. If you haven't done so already, I strongly suggest participating in the survey now.

The Context

For those unaware, the primary motivation for the survey is to make sure the right features make it into Java EE 8. After months of silent inactivity, Oracle has announced that it is committed to delivering Java EE 8 in time.  While this is undoubtedly good news, a potential problem is that Oracle appears to wish to significantly shift the focus of Java EE 8 compared to the initially promised, highly community-driven scope. The best way to figure out if what Oracle seems to be proposing is the right thing to do is by asking your opinion on Java EE 8 scope through a survey.

Categories: Java

Why I Introduced Scala In Our Project

Javalobby Syndicated Feed - Thu, 01-Sep-16 05:31

I don’t like Scala, and I think it has some bad and very ugly aspects that make it a poor choice for mainstream development.

But recently I still introduced it in our project. Not only that, but the team had no experience with Scala. I’ll try to explain why that is not a bad idea.

Categories: Java

How to handle unfinished User Stories in Scrum

codecentric Blog - Thu, 01-Sep-16 03:48

Have you heard of Berlin’s new airport? Landing of the first plane was originally expected for 2007, then for 2010, later it was 2011, 2012, 2013,… – and making a long story short: the grand opening party for 2017 was just postponed for an undefined time.

Whether we talk about building airports or about building software, people tend to underestimate the amount of unfinished work. Well, even if they don’t, most people tend to give a more boss- or customer-friendly answer: “I’m 95% done” just sounds better than “I’m in the middle of this complex thing, and yes, I underestimated it, and to be honest, I don’t know what other unforeseen problems will occur on my way to the solution.”

empty airport

Although this nearly-done-status sounds good; it’s a killer for transparency on the project status. That’s why in agile development – for example with the Scrum process – you only care about entirely completed features. It’s binary. In the Scrum demo meeting you look at each User Story, check it against all acceptance criteria and the team’s definition of done (DoD). Only if all the work is done, all NFRs and other parts of the DoD are satisfied, only then the User Story is resolved and closed.

In agile software development the status of a feature is binary. Done or not done – Nothing in between.

It’s okay to slice User Stories, for example by workflow steps, business rules or by data variation to make them fitting into a sprint; but the defined scope and quality needs to be finished completely. Do not let a development team go away with resolving User Story A because it’s nearly done and at the same time adding a new Story “Finishing last bits of User Story A” to the backlog.

Saying that means we need to define how to handle unfinished features. I worked with many teams where this question was discussed extensively and emotional. If you work with Story Points the development teams often feel treated unfairly, if they finished “95% percent” (see above) of the work, but don’t get any credits for it. These discussions are getting even more emotional in environments where the management misunderstands Scrum and the concept of Story Points and judges Scrum Teams by their velocity.

So again, how to handle unfinished User Stories in Scrum?

My first answer is: You should not care too much about this question. It should be an exceptional case that the team did not finish a User Story. So, no matter what solution you choose, it shouldn’t have a significant impact on any of your metrics. If this is not true for your team, you have another problem you should solve; instead of fighting symptoms by giving your team credit for half-baked implementations.

Don’t care too much about an exceptional case!

The second part of my answer is: Unfinished stories should not be part of the demo meeting. They are moved to the top of the Product Backlog, instead of going automatically to next Sprint’s Backlog. So no Story Points are marked done for an unfinished story. Before the next planning meeting the PO (after consultating the developers) decides if he/she wants to spend more time on this User Story. If the answer is “yes”, during next planning meeting the User Story is moved to the Sprint Backlog with the same estimation as it had originally. Even if developers pretend that the feature is 90% done – all Story Points go to the velocity of this new Sprint. As I said before, unfinished stories should be exceptional, therefore in the long term team’s velocity will average out smoothly. Even though I hope that you’ll finish your projects faster than these guys from the BER.

See also:

https://www.mountaingoatsoftware.com/blog/dont-take-partial-credit-for-semi-finished-stories

The post How to handle unfinished User Stories in Scrum appeared first on codecentric Blog.

Categories: Agile, Java, TDD & BDD

Beginners Guide to Functional Programming: Part 1

Javalobby Syndicated Feed - Thu, 01-Sep-16 02:31

Introduction

Steven Sacks, a friend of mine, and I have been learning Functional Programming over the past year. We’ve both cut our teeth on finding who to learn from, what articles are useful, and what actually translates into your day to day programming job. I’ve also learned a lot of natural problems that arise as you start a new project from scratch with an OOP background, or if you’re refactoring some OOP code to be more functional.

In this article, I wanted to share some of what I learned. Specifically what functional programming is, why it matters, how to use pure functions, and list comprehensions in the real world. While I use JavaScript in this article, I’ve learned that the concepts and libraries supporting it are available in many programming languages.

Categories: Java

Different Types of References in Java

Javalobby Syndicated Feed - Thu, 01-Sep-16 00:31

Many Java developers are not aware that Java has four main types of references.

  • Strong Reference
  • Weak Reference
  • Soft Reference
  • Phantom Reference

But why there are different types of reference? What are they used for? To understand that I will go over an example:

Categories: Java

Applying JDK 9 @Deprecated Enhancements

Javalobby Syndicated Feed - Wed, 31-Aug-16 22:31

I discussed the currently proposed JDK 9 enhancements for the @Deprecated annotation in the blog post JDK 9 @Deprecated Annotation Enhancements. In this post, I look in greater detail at the recommended usage of these minor enhancements and demonstrate how key Java SE APIs are already having these @Deprecatedenhancements applied.

The current version of the main JEP 277 ("Enhanced Deprecation") web page states, "The primary purpose of enhancing the @Deprecated annotation is to provide finer-grained information to tools about the deprecation status of an API." The page also describes the two new methods being added to the@Deprecated annotation [forRemoval() and since()]:

Categories: Java

This Week in Spring: New Releases All the Way Down

Javalobby Syndicated Feed - Wed, 31-Aug-16 05:31
Welcome to another installment of This Week in Spring! This week I’ve been in San Francisco, (where I live and) where I addressed the Silicon Valley Spring User Group. Now it’s off to beautiful China to bring some Spring and Pivotal (and, maybe, take a little vacation!)

As usual, we have a lot to get to so let’s!

Categories: Java

Understanding Reactor Pattern: Thread-Based and Event-Driven

Javalobby Syndicated Feed - Wed, 31-Aug-16 02:31

To handle web requests, there are two competing web architectures: thread-based and event-driven architectures. 

Thread-Based Architecture

The most intuitive way to implement a multi-threaded server is to follow the thread-per-connection approach. It is appropriate for sites that need to avoid threading for compatibility with non-thread-safe libraries.

Categories: Java

Java 8 — ZonedDateTime Examples

Javalobby Syndicated Feed - Wed, 31-Aug-16 00:34

Here are a few java.time.ZonedDateTime examples to show you how to convert a time zone between different countries.

1. Malaysia (KUL) -> Japan (HND)

Review a flight information from Malaysia Kuala Lumpur (UTC+08:00) to Japan Tokyo Haneda (UTC+09:00)

Categories: Java

Announcing Hazelcast 3.7 General Availability

Javalobby Syndicated Feed - Tue, 30-Aug-16 23:34

I am really proud to introduce this latest “go-to” release of Hazelcast. So much testing and very high standards mean that each release is a major milestone.

With this release, we have made major structural improvements such as the full realization of our modularization strategy and really significant performance increases- 30% faster than Hazelcast 3.6. Which is a big deal when you are already the fastest in-memory data grid in the market. But that isn’t the end of story.

Categories: Java

Java 9 Modularity: O'Reilly Early Access Release

Javalobby Syndicated Feed - Tue, 30-Aug-16 22:31

Earlier this year my colleague Paul Bakker and I started working on the first drafts of Java 9 Modularity. We're proud to announce that the first bits of what will become the final book are now publicly available!

You can now order the Early Access release of our upcoming book through O'Reilly's webshop: http://shop.oreilly.com/product/0636920049494.do. It is also available on Safari Books online, if you have a subscription there. If you prefer reading the final edition on real paper, you can even pre-order at Amazon already.

Categories: Java

Poll Results: Which 'Elements of Programming Style' Are Totally Wrong? [125 responses]

Javalobby Syndicated Feed - Tue, 30-Aug-16 21:01

Last week we asked what you thought of Kernighan and Plauger's classic Elements of Programming Style. 125 responded, which doesn't strongly represent the whole world's developer population (if the sample were totally randomly selected from all developers in the world (which it isn't), and if the one-question poll had only two answer options, then at a 95% confidence level the confidence interval would be a pretty big 9), but results are worth examining at least to understand our own community better.

Full results are embedded below and accessible here. Three points worth calling out at first pass:

Categories: Java

TDD and Design: Frameworks

Sustainable Test-Driven Development - Tue, 30-Aug-16 11:51
Increasingly, in modern software development, we create software using components that are provided as part of a language, framework, or other element of an overall development ecosystem.  In test-driven development this can potentially cause difficulties because our code becomes dependent on components that we did not create, that may not be amenable to our testing approaches, and that the test Scott Bainhttp://www.blogger.com/profile/05410128716057054818noreply@blogger.com0
Categories: TDD & BDD

Spring Cloud Data Flow for Mesos 1.0 RC2 Released

Javalobby Syndicated Feed - Tue, 30-Aug-16 05:31

We are pleased to announce the 1.0.0.RC2 release candidate of Spring Cloud Data Flow for Mesos, a team effort that encompasses many new features under the hood.

This release candidate builds upon the recent 1.0 GA release of Spring Cloud Data Flow. Some highlights include:

Categories: Java

Thread Slivers eBook at Amazon

Syndicate content