Feed aggregator

Develop and Deploy Microservices With JHipster

Javalobby Syndicated Feed - Wed, 19-Jul-17 21:01

JHipster is one of those open-source projects you stumble upon and immediately think, "Of course!" It combines three very successful frameworks in web development: Bootstrap, Angular, and Spring Boot. Bootstrap was one of the first dominant web-component frameworks. Its largest appeal was that it only required a bit of HTML and it worked! Bootstrap showed many in the Java community how to develop components for the web. It leveled the playing field in HTML/CSS development, much like Apple’s Human Interface Guidelines did for iOS apps.

At its core, JHipster is a Yeoman generator. Yeoman is a code generator that you run with a yo command to generate complete applications or useful pieces of an application. Yeoman generators promote what the Yeoman team calls the "Yeoman workflow" This is an opinionated client-side stack of tools that can help developers quickly build beautiful web applications. It takes care of providing everything needed to get working without the normal pains associated with a manual setup.

Categories: Java

Extending Spock: Outputting the Given/When/Then

Javalobby Syndicated Feed - Wed, 19-Jul-17 13:01

Spock is a Java testing framework created in 2008 by Peter Niederwieser, a software engineer with GradleWare, which facilitates, amongst other things, BDD. Leveraging this example, a story may be defined as:

Story: Returns go to stock

As a store owner
In order to keep track of stock
I want to add items back to stock when they're returned.

Scenario 1: Refunded items should be returned to stock
Given that a customer previously bought a black sweater from me
And I have three black sweaters in stock.
When he returns the black sweater for a refund
Then I should have four black sweaters in stock.

Scenario 2: Replaced items should be returned to stock
Given that a customer previously bought a blue garment from me
And I have two blue garments in stock
And three black garments in stock.
When he returns the blue garment for a replacement in black
Then I should have three blue garments in stock
And three black garments in stock.


Categories: Java

This Week in Spring: Spring 5, Trampoline, and JDK 9 Collections

Javalobby Syndicated Feed - Wed, 19-Jul-17 09:01

Hi Spring fans! This week I’m in Crete, Greece, for the epic JCrete un-conference. and then it’s off to Istanbul, Turkey, for next week’s visits with customers and for the Spring meetup. I hope you’ll join me in Istanbul!

As usual, we’ve got a lot to cover so let’s get to it!

Categories: Java

Specifying and Handling Exceptions

Javalobby Syndicated Feed - Wed, 19-Jul-17 00:01

Errors happen all the time in the software world. It might be an invalid user input or an external system that is not responding, or it’s a simple programming error. In all these situations, the errors occur at runtime and the application needs to handle them. Otherwise, it crashes and can’t process further requests. Java provides a powerful mechanism which allows you to handle the exceptional event where it occurred or in one of the higher methods in the call stack. Before we get into the details of Java’s exception handling, we need to define a few terms.

Java Exception Handling: Common Terminology

Call Stack

The call stack is the ordered list of methods that had been called to get to a specific method. In the context of this post, these are the methods which were called to get to the method in which the error occurred.

Categories: Java

Defining Bean Dependencies With Java Config in Spring Framework

Javalobby Syndicated Feed - Tue, 18-Jul-17 21:01

I found it hard to choose a topic to describe in my first blog post. I wanted it not to be too trivial, nor too complicated It turned out that there are many basic concepts in Spring Framework that can be confusing. Java-based configuration is one of them. I hear my colleagues asking from time to time about it, and I see numerous questions regarding it on StackOverflow. Nevermind the motivation, below you will find a compact description of how to declare beans with Java Config.

Please note that this post won't cover bean dependencies of different scopes nor discussion on annotations like @Component@Service@Repository, etc., that are often a good alternative to the described approach. Java Config might seem to be overkill in many situations, but I hope you will find the post useful anyway. Let's go!

Categories: Java

4 Techniques for Writing Better Java

Javalobby Syndicated Feed - Tue, 18-Jul-17 14:23

Day-in and day-out, most of the Java we write uses a small fraction of the capability of the language's full suite of possibilities. Each Stream we instantiate and each @Autowired annotation we prefix to our instance variables suffice to accomplish most of our goals. There are times, however, when we must resort to those sparingly used portions of the language: The hidden parts of the language that serves a specific purpose.

This article explores four techniques that can be used when caught in a bind and be introduced into a code-base to improve both the ease of development and readability. Not all of these techniques will be applicable in every situation, or even most. For example, there may be only a few methods that will lend themselves to covariant return types or only a few generic classes that fit the pattern for using intersectional generic types, while others, such as final methods and classes and try-with-resources blocks, will improve the readability and clearness of intention of most code-bases. In either case, it is important to not only know that these techniques exist, but know when to judiciously apply them.

Categories: Java

Java 9 Modular Development (Part 2)

Javalobby Syndicated Feed - Tue, 18-Jul-17 13:01

In my previous post, we discussed modularity, module descriptors, and the details about module-info.java files. This article will help in developing a modular project step by step and packaging them as JARs and JMODs and also describes the steps needed to create runtime images by using jlink.

We will be developing a small modular project that will print, "Hello Welcome to Java 9 Modularity" in the console.

Categories: Java

The Maven Way to Add Non-Maven JARs to a Maven Project [Snippets]

Javalobby Syndicated Feed - Tue, 18-Jul-17 09:01

Have you ever asked, "How do I add custom (non-maven) JARs as dependencies to maven projects, in a maven way?"

Answer: Easy. Use the maven-install-plugin maven plugin,

Categories: Java

Akka Concepts: Testing Actors

Javalobby Syndicated Feed - Tue, 18-Jul-17 03:01

With Akka, remember that actors interact only via message passing. In order to check actors' behaviors, you can do it through the messages sent and received to and from them. So, how do you test actors? You send them messages.

To test actors that communicate only with messages, you need to send it a message, get a reply back, and check it.

Categories: Java

Blockchain, the next big thing?

codecentric Blog - Mon, 17-Jul-17 23:00

All started in 2009 when the mysterious pseudonym Satoshi Nakamoto published and started Bitcoin. It was identified as the first ever decentralised currency enabling users to perform peer to peer money transactions without a central authority. Bitcoin was the first application to implement the Blockchain technology while it’s inventor was still not identified.

As of today, there are over 800 cryptocurrencies relying on the Blockchain. Some just want to improve Bitcoin on a technical base, others extended or re-invented aspects of the Blockchain. They pushed other components, mechanisms and algorithms into place to solve problems of Bitcoin or answer their custom requirements.
Quite a lot of them do not want to be plain digital money. They are powering and financing digital products like for example decentralised cloud storage or a global supercomputer with it.

A lot of products and companies start using the Blockchain for other business cases than digital currencies. To know why that is, we will have a look at the concepts and components of the Blockchain. Later on we will reflect on the resulting advantages and disadvantages and why we all should keep an eye on the Blockchain technology.

What is the Blockchain?

In essence we are talking about a distributed system to store a history of transactions on each member of the system. There is no central instance that keeps track of the one and only true history, therefore a Blockchain is always eventually consistent. The individual parts of the system might have a different state but will at some point reach a common agreement.

The structure of a Blockchains’ history is not only a table in a database. Transactions in the history could be imagined as a changelog of the system that reference each other by being put into a structure.
To make this structure of a Blockchain complete we are missing another component. But let us first learn what a transaction is.

What actually is a Transaction?

Using the example of Bitcoin, a transaction is an event that describes the transfer of a balance from one known participant to another. It contains the sender, receiver and the amount to be transferred.
Considering other areas of application, this could be any data that describes a transfer between two involved parties. For example the movement of Italian wine along its whole value chain in order to record the exact process and guarantee its authenticity.

A transaction is an action or event which is appended to the history of the Blockchain. The type of data contained doesn’t really matter.
But how does it work? Whom to ask to perform the transaction? How to validate if this is a permitted action? How do they get processed?
We need a few more concepts to close the circle of a working Blockchain.

Shouldn’t there be Blocks in a Blockchain?

Yes, there are blocks in a Blockchain because if we would directly chain transactions, it would be called something like transaction chain, wouldn’t it?
Blocks are containers for multiple transactions with extra information, comparable to a header of a network protocol like IP. Each block is granted a unique hash as identifier, contains a bunch of transactions and also references the previous block.

Blocks do exist as a super unit for multiple transactions for different reasons. Depending on the scenario blocks have different meta information and size. To verify the integrity of transactions, blocks contain a checksum of them and put them in their header. As information from the header is hashed and referenced in the next block header, integrity is created.

A blockchain consists of transactions and blocks that reference each other by hashing the previous one

There is still the remaining question of how transactions get validated and confirmed so a transfer of balances with currencies like Bitcoin is possible.

How riddles fuel the Blockchain

When a transaction is created (containing sender, data and recipient) it has to be sent to the Blockchain network. Meaning to one part of the network that broadcasts it to the other participants.
Unfortunately transactions are not directly executed but have to wait for something described as “processing”. They get validated in order to be summarised in blocks and attached to the history.

It would be a mess without validation as participants could pretend to have more money than they actually do. We need to check if the balance of the sender is sufficient for the transfer.
As there is no decimal containing the amount a participant owns, the balance has to be computed from the Blockchain history. The history describes the origin of a balance and how it moved through the ledgers of others by transactions.
The balance, for example Bitcoins, is no file or pointable thing in the network but result of aggregating the history.

How are the initial balances of the first participants in a Blockchain created? And what do they have to do with riddles?

Well, the riddles in Bitcoin are what we know as mining. Miners (or nodes) are keeping up a Blockchain network by processing transactions. To process transactions and append them to the history in blocks, these blocks require you to solve a complex mathematical problem.
So, validating and processing transactions is designed in the form of mathematical riddles in most cryptocurrencies.

This approach is called Proof of Work (PoW) because if one managed to solve one of these blocks, he proved that he did a lot of work for it. In reality that work is achieved by a lot of complex computations and hashing which costs electric power.
Digital currencies reward miners with some coins per solved riddle, so it pays off for them to do the work. The difficulty of a Blockchain network increases over time making it harder for miners to find blocks (for Bitcoin this happens every 2016 blocks).

Besides PoW there are also other possibilities like Proof of Stake or Proof of Importance that may make sense for different purposes. They mainly want to solve the waste of electric power that is involved in PoW. This is done by creating other kinds of nodes that process transactions not depending on their energy consumption but on their stake of the network or their importance as a user of the network.

What is it useful for?

Blockchains aim to provide an unchangeable, secure and perfectly verified history. As the history is replicated over all nodes participating in the network there is no single point of failure by design. The aim is to cryptographically ensure the impossibility of changing transactions in the history without invalidating the following ones. Also Blockchains are designed to be highly available and can be operated with an infinite amount of nodes.

A blockchain network consists of an infinite amount of nodes that communicate in a peer to peer matter

On the other side Blockchains, cryptography and distributed systems themselves are very complex topics. If the advantages of Blockchain are not utilised by a use case, it does not make sense to use it. On a technical base one hard decision comes after another. For example scaling is a known issue with lots of different solutions.

Like every other technology or architecture the Blockchain is not the solution to everything. It has strong advantages and disadvantages that should be wisely considered when contemplating its application. It describes a vague concept that has many setscrews for customisation. Cryptographic algorithms, distributed consensus mechanism and many more implementation details are adjustable and make each Blockchain unique.

Its strong points pay off perfectly for digital currencies, services and market places that want to exclude central authorities like banks or governments.
Furthermore applications that require data security and validity to implement fraud detection or authenticity in some way will profit from the concept.

Conclusion

Blockchain is a stunning technology that has high potential for a lot of use cases. More and more governments and institutions are adapting it, also for non-payment areas. Estonia implemented an identity management using Blockchain, the Republic of Georgia registers land titles with it and new project kickoffs are happening on a weekly base.
Also the area of digital currencies is very vivid and new payment methods and platforms are trying to disrupt the classical finance industry.

Like all great inventions in the tech sector it gets hyped and companies tend to see it as silver bullet. This is of course not the case, usage of any technology must be considered carefully.
When deciding for using a Blockchain there are complex decisions ahead.
After all, we’re looking forward to see more great projects and fascinating developments in this area in the future.

The post Blockchain, the next big thing? appeared first on codecentric AG Blog.

Categories: Agile, Java, TDD & BDD

Beginning to Doubt Object-Oriented Programming

Javalobby Syndicated Feed - Mon, 17-Jul-17 21:01

Before I say anything meaningful and start winning or losing your sympathy, let me make something very clear: I am an OO guy. My first programming language was C++, then I learned Java, Groovy, Kotlin, JavaScript, and probably some others. Aside from playing with Clojure at home and a bit of C at university, I haven't done any serious non-OO programming in my life.

With that in mind, I recently watched a presentation titled Simple Made Easy by Rich Hickey, the creator of Clojure. The presentation contained a pretty compelling definition of the term “simple” and explained the benefits of functional programming in a way that things finally clicked in my head. Let’s get down to the details.

Categories: Java

Reactive Streams With Spring Data and MongoDB

Javalobby Syndicated Feed - Mon, 17-Jul-17 21:01

This is a short post looking into Reactive Streams and how they can be used with MongoDB and Spring Data. This post won’t go into the depths of what Reactive Programming and Reactive Streams are, as there have been plenty of posts covering that recently, such as What are Reactive Streams in Java and Reactive Spring 5 and Application Design Impact. Instead, it will simply demonstrate how to use the newer versions (at the time of writing) of Spring Data, which comes equipped with the features necessary to use Reactive Streams. In this post, we will be using MongoDB due to it being one of the few currently available databases with a Reactive implementation with Spring Data. The others include (at the time of writing) Cassandra and Redis.

In terms of getting everything set up, not much is different to using the non-Reactive version of MongoDB with Spring Data. The main difference that you will see is that the word “reactive” pops up into loads of class names, such as ReactiveMongoRepository instead of MongoRepository, hopefully helping you distinguish between them. The other main difference is that, instead of returning a document or a list of documents, you will now receive some slightly different objects. In this post, we will use Reactor as our Reactive Streaming library, meaning that the returned objects are Mono<T> for a singular document and a Flux<T> when multiple documents are being returned. For more information on Flux and Mono from Project Reactor, have a look at this Intro into Reactor Core.

Categories: Java

Building and Deploying Scala Apps

Javalobby Syndicated Feed - Mon, 17-Jul-17 03:01

Hey! Looks like you're familiar with Scala. And I believe you've even developed some apps locally using it. One of coding's main missions is to help people to solve their problems. But how can your apps do this if they are running locally on your laptop? In this post, I want to show the easiest way to deploy a Scala application.

How to Build a Scala Project

What do I mean by saying “build” a Scala project? Well, it means that the project, running locally from the IDE, should be “transformed” into something that can be launched from any other environment (Linux / Windows / Mac).

Categories: Java

Get Started With Spring Boot, SAML, and Okta

Javalobby Syndicated Feed - Mon, 17-Jul-17 01:01

Today I’d like to show you how to build a Spring Boot application that leverages Okta’s Platform API for authentication via SAML. SAML (Security Assertion Markup Language) is an XML-based standard for securely exchanging authentication and authorization information between entities — specifically between identity providers, service providers, and users. Well-known IdPs include Salesforce, Okta, OneLogin, and Shibboleth.

My Okta developer experience began a couple years ago (in December 2014) when I worked for a client that was adopting it. I was tasked with helping them decide on a web framework to use, so I built prototypes with Node, Ruby, and Spring. I documented my findings in a blog post. Along the way, I tweeted my issues with Spring Boot, and asked how to fix it on Stack Overflow. I ended up figuring out the solution through trial-and-error and my findings made it into the official Spring documentation. Things have changed a lot since then and now Spring Security 4.2 has support for auto-loading custom DSLs. And guess what, there’s even a DSL for SAML configuration!

Categories: Java

Microservices Communication: Eureka Client

Javalobby Syndicated Feed - Mon, 17-Jul-17 00:01

In my previous Java microservices tutorial example, I created a Eureka Server. In this tutorial, I will show you how microservice communication happens. In this tutorial, I will create a Eureka client that communicates with a Eureka server — a microservices service registry.

If you haven't gone through the previous articles, please click here.

Categories: Java

Mocks or the real thing? Tips for better unit testing

codecentric Blog - Mon, 17-Jul-17 00:00

Recently I had to bone up on some of the new features in Mockito 2 and Powermock, though more out of necessity than from genuine curiosity. Powermock and Mockito 2 let you fake static methods, final classes and even constructor calls, but this has been possible for some time with the JMockit framework, which handles these cases without special syntax or extra boilerplate code. This is not going to be a tutorial about how to exploit the advanced features in modern mocking frameworks. Rather, it’s a warning that these features work around design decisions that were wrong to begin with and that it is the class under test that needs fixing, not the unit test.

The code whose test coverage I was supposed to jack up – notice how wrong that sounds – was a tough nut to crack. The classes under test had many dependencies that were either invoked statically or instantiated through UserDao userDao = new UserDao(new Connection()); when they should have been injected. The test suite only stubbed or mocked handles to networked services. All database handles – how is that not a networked service? – used the real thing. So most of the existing tests were really integration tests posing as unit tests.

Here’s a little refresher. What’s wrong with static methods and constructors calls? The answer it tight coupling. If you explicitly create an instance of, say, an OracleDataSource in your code rather than a javax.sql.DataSource you introduce a compile-time dependency to that implementation. If you let the container (any dependency injection framework will do) create an instance of that datasource and inject the value you can treat it as a generic javax.sql.DataSource interface. Constructing and managing objects is a separate concern from using them, and especially with pooled resources like database connections that have their own lifecycle management you shouldn’t create them yourself. A more practical reason to delegate object construction though is that new(..) makes unit testing awkward.

21 per cent forever

Another refresher: why do we need a mocking framework at all? Why do we want to replace certain objects in our class under test with these weird proxies? It’s because we want to make our unit tests autistic. Any non-trivial class is likely to have dependencies on other classes. Some are part of the same source root, others belong to the core library (java.util.ArrayList, java.io.File) and a considerable bulk are in third-party libraries. These dependencies may be very trustworthy and behave  predictably, but they might also depend on more fickle external resources like the filesystem or network. Any object that uses the curent date/time or does other hardware read-outs is unpredictable by definition. That’s terrible for testing. In a unit test we want to make sure that the world outside the class under test behaves exactly the way we want. Suppose we’re testing an InvoiceBuilder that uses a service to retrieve the VAT rate for a country.

double vatRate = VATService.getVATRateForCountry(countryCode);

The test case assumes that the VAT rate for the Netherlands is 21 per cent, but we can’t know that unless we peek into the internals of the VATService class. Perhaps it relies on a local file or maybe it accesses a VAT lookup REST server, which slows down the test by orders of magnitude. Unit tests should be fast as lightning and run without elaborate setting up of resources. If you want to reap the benefits of mutation testing then speed of execution is an essential. There is also a more principled reason. Unit tests are not there to make sure that your application as a whole works as intended. For that purpose you have your integration tests, your end-to-end tests, stress tests, and your stressed human testers. Unit tests are deliberately designed to be short-sighted. When a unit test runs a piece of code it must treat anything external to that code as a given, i.e. be oblivious to its internals. The test wants the Dutch VAT rate to be written in stone, long after the North Sea has reclaimed the Low Countries. For that we want to mock. Behold the mother of non-deterministic code:

LocalDateTime now = LocalDateTime.now();
File file = new File(PATH + formatDate(now));
FileUtils.writeLines(file, 
     Arrays.asList("This file was created on:", formatDate(now)));

No exception was thrown, so we know that some file was written, but we don’t know its name or contents, because that was based on the current date. I want to freeze time on 14 July 2017 11:45, so I can open a file named TEST_14_7_2017_11_15. Actually, forget I said that. I don’t want to open any file. I trust  that Apache FileUtils is a stable library. I only want to make sure that its writeToFile method is invoked with a File whose path and timestamp are correct. Powermock can do it, but it’s not as straightforward as mocking simple injectable instances:

  • You have to explicitly specify the classes in a @PrepareForTest(MockableDependency.class) annotation, including the class containing the class you want to construct.
  • You have to invoke PowerMockito.mockStatic(MockableDependency.class)
  • The syntax for verification is different and constructors are cumbersome: whenNew(SomeClass.class).withArguments(..).thenReturn(..)

This somewhat contrived example shows you when you absolutely need a mocking framework to make things testable. Later I’ll show you there’s a simpler and better way than mocking statics and constructors.

To mock or not to mock?

Suppose our VATService is backed by a hard-coded enumeration. What if after an update by the VAT team the service suddenly returns a percentage of 20 rather than a fraction (0.2). What if our FileUtils example suddently has no write privileges? Had you used the real thing then your unit test would have stumbled over the illegal state. Now that it’s mocked it will go sour in production! Assuming there’s no test setup required and performance penalty in using the VAT service for real, would it not be better to use the real thing rather than a mock? NO IT WOULD NOT! A unit test is not responsible for anything but the class under test. No amount of testing on your laptop can prevent things from crashing under a production load. Maybe the VAT service is a memory hog. It’s still beyond the scope of the unit test. To prevent disasters we have integration and end-to-end tests. They’re no less important than unit tests, but of a different order. If the contract – the output given certain input — of your class changes, so should the mocked verifications. Imagine a data access object (DAO) that used to return null for an invalid key but now throws a ThingyNotFoundException.

Obligatory candidates for mocking are anything network related, database connections or anything to do with the file system. A special case is code that produces unpredictable results, like the current time. You should only ever use the real dependency if its behaviour is completely deterministic, there’s no setup involved and no performance hit. A good example is the standard collection library, or utilities such as Apache StringUtils. We can assume they work as designed. Anyway, if you feel you need to test the correctness of an external library, should you really use it in production? Note that the choice to mock FileUtils and use the real thing for StringUtils has nothing to do with the quality of the library: it’s the interaction with the file system that we want to keep out of the unit test.

Wrap it up

So static invocations and constructors can be a sign of bad design practice. While they are ‘mockable’, Powermock and JMockit work best with a dependency injection approach. The bytecode manipulation voodoo involved to make statics work are not without problems, especially with older or non-standard JDKs. It’s like most prescription medicine: a sub-optimal means with nauseating side effects to cure a disease often caused by bad habits. Powermock does things right, but it’s a cholesterol pill. We are not doing the right thing if we have to use it often. But sometimes we have no choice. FileUtils and other similar stateless libraries (e.g. LocalDate.now()) are built around static methods. What to do?
The Facade pattern to the rescue! Write a simple wrapper around it that exposes only the calls you want and inject instances of that. The advantages:

  • it hides the implementation and doesn’t tie you in to Apache FileUtils.
  • It hides what you don’t need and you can customise it to reduce error and make it more user-friendly.
  • You can mock it much more easily.

Now that you have isolated all usages of FileUtils in very lean Facade, you can choose to unit test it using static mocks or forgo the unit test entirely and integration-test it, using real files. How about constructors? It depends on the kind of object you’re making. If it is an instance member containing logic and behaviour such as the VATService you should let the framework inject it. If it’s a typical Employee data object that gets ‘newed’ all over the place then it probably belongs in a dedicated factory, injected as a mockable dependency.

Train wrecks

One final warning to dampen your spirits should I have given you the wrong impression that mocks are always fun to work with. Here’s a little made-up yet painfully reminiscent example:

String postCode = employeeDao
     .getEmployeeById(employeeId)
     .getPreviousEmployer()
     .getAddress()
     .getPostCode();

Forget about the absence of null-safety (if only everybody used Kotlin), this is just typical train wreck notation. It’s a bear to test with or without mocks.

when(employeeDao.getEmployeeById(42)).thenReturn(employee);
when(employee.getPreviousEmployer()).thenReturn(previousEmployer);
when(previousEmployer.getAddress()).thenReturn(address);
when(address.getPostCode()).thenReturn(“1234AB”);By Jove, we’re finally there!

Sniffing out code smells

Unit tests are great at sniffing out code smells. Code that is hard or impossible to unit test is always cause for concern. If you struggle with the mocking framework or can’t do without a monstrous base class or helpers to get the unit tests going, then it’s the class under test that has sprouted the evil green hairs and it is time for refactoring. Better late than never. Stick to a test-driven approach and this is much less likely to happen.

The post Mocks or the real thing? Tips for better unit testing appeared first on codecentric AG Blog.

Categories: Agile, Java, TDD & BDD

Don’t Extract Everything Into a Method

Javalobby Syndicated Feed - Sun, 16-Jul-17 21:01

Every now and then, I tweet something like this, just to piss off some clean coders:

Apart from the obvious trolling factor (why can’t I ever resist?), I do think there’s something thought-provoking in such a tweet.

Categories: Java

Java Web Services: Improve App Communication and Flexibility

Javalobby Syndicated Feed - Sat, 15-Jul-17 22:01

Web services have taken the development world by storm, especially in recent years as they’ve become more and more widely adopted. There are naturally many reasons for this, but first, let’s understand what exactly a web service is.

The World Wide Web Consortium (W3C) defines “web of services” as “message-based design frequently found on the Web and in enterprise software”. Basically, a web service is a method of sending a message between two devices through a network.

Categories: Java

Java Jobs, These Companies Are Hiring!

Javalobby Syndicated Feed - Sat, 15-Jul-17 03:01

DZone Jobs has some great opportunities for Java developers!  Are you looking for a remote dev position that gives you a little more flexibility?  Maybe you want to be closer to home, or it's time in your career that you'd like a leadership role. Whatever it may be, you just might find your next job listed among the open positions below.

Senior Software Engineer 

Carbon Black, Inc. 

Categories: Java

What Are Reactive Streams in Java?

Javalobby Syndicated Feed - Fri, 14-Jul-17 21:01

If you’re following the Java community, you may be hearing about Reactive Streams in Java. It seems like in all the major tech conferences, you’re seeing presentations on Reactive Programming. Last year, the buzz was all about functional programming, this year the buzz is about Reactive Programming.

So, is the attention span of the Java community that short-lived? Have we Java developers forgotten about functional programming and moved on to Reactive programming?

Categories: Java

Thread Slivers eBook at Amazon

Syndicate content