Split and Clone Editor Views in Eclipse

Sometimes it is all about knowing the simple tricks in Eclipse which make life easier. Like this one: How to have a split editor view so I can edit multiple different sections of a source file.That feature is present in Eclipse Luna and afterwards, but because there is no icon in the view itself as in Microsoft Word, I have found that many do not know about this useful feature. The screensthots below are for Eclipse Luna.Split Editor ViewTo split an editor view, I have it selected (to be active), then I use the menu ‘Toggle Split Editor’:I can split it horizontal:Or in a vertical way:I can use the mouse to resize the split area:To remove the split, simply use the menu or shortcut again:Clone Editor ViewThe other useful function is to clone an Editor view:This creates a clone of that view:To ‘undo’ the cloning, I close the new editor view.SummarySplitting and Cloning gives me a way to edit the same source file in different portions of that file. The commands to Clone and Split is under the Window > Editor menu.Happy Cloning and Splitting! Read more

The Life of a Serverless Microservice on AWS

In this post, I will demonstrate how you can develop, test, deploy, and operate a production-ready serverless microservice using the AWS ecosystem. The combination of AWS Lambda and Amazon API Gateway allows us to operate a REST endpoint without the need of any virtual machines. We will use Amazon DynamoDB as our database, Amazon CloudWatch for metrics and logs, and AWS CodeCommit and AWS CodePipeline as our delivery pipeline. In the end, you will know how to wire together a bunch of AWS services to run a system in production.The LifeMy idea of "The Life of a Serverless Microservice on AWS" is best described by this figure:A developer is pushing code changes to a repository. This git push triggers the CI & CD pipeline to deploy a new version of the service, which our users consume. The load generated on the system produces logs and metrics that are used by the developer to operate the system. The operational feedback is used to improve the quality of the system.What is Serverless?Serverless or Function as a Service (FaaS) describes the idea that the deployment unit is a single function. A function takes input and returns output. The responsibility of the FaaS user is to develop the function while the FaaS provider's responsible is to execute the function whenever some event happens. The following figure demonstrates this idea.Some possible events:File uploaded.E-Mail received.Database changed.Manual invoked.HTTP API called.Cron.The cool things about serverless architecture are:You only pay when the function is executed.No under/over provisioning.No boot time.No patching.No SSH.No load balancing.Read more about Serverless Architectures if you are interested in the details.What is a Microservice?Imagine a small system where users have a public visible profile page with location information of that user. The idea of a microservice architecture is that you slice your system into smaller units around bounded contexts. I identified three of them:Authentication Service: Handles authentication.Location Service: Manages location information via a private HTTP API. Uses the Authentication Service internally to authenticate requests.Profile Service: Stores and retrieves the profile via a public HTTP API. Makes an internal call to the Location Service to retrieve the location information.Each service gets its own database, and services are only to communicate with each other over well-defined APIs, not the database!Let's get started!The source code and installation instruction can be found at the bottom of this page. Please use the us-east-1 region! We will use services that are not available in other AWS regions at the moment.CodeAWS CodeCommit is a hosted Git repository that uses IAM for access control. You need to upload your public SSH key to your IAM User as shown in the following figure:Creating a repository is simple. Just click on the Create new Repository button in the AWS Management Console.We need a repository for each service. You can then clone the repository locally with the following command. Replace $SSHKeyID with the SSH Key ID of your IAM user and $RepositoryName with the name of your repository.git clone ssh://$SSHKeyID@git-codecommit.us-east-1.amazonaws.com/v1/repos/$RepositoryName` We now have a home for our code.Continuous Integration & Continuous DeliveryAWS CodePipeline is a service to manage a build and deployment pipeline. CodePipeline itself is only responsible triggering integrations to do things like:Build.TestDeploy.We need a pipeline for each service that:Downloads the sources from CodeCommit if something changes there.Runs our test and bundles the code in a zip file for Lambda.Deploys the zip file.Luckily, CodePipeline has native support for downloading sources from CodeCommit. To run our tests, we will use a third-party integration to trigger Solano CI to run our tests and bundle the source files. The deployment step is implemented in a Lambda function that triggers a CloudFormation stack update. A CloudFormation stack is a bunch of AWS resources managed by CloudFormation based on a template that you provide (Infrastructure as Code). Read more about CloudFormation on our blog.The following figure shows the pipeline:The cool thing about CloudFormation is that you can define the pipeline itself in a template. So we get Pipeline as Code.The CloudFormation template that is used for service deployment describes a Lambda function, a DynamoDB database, and an API Gateway. After deployment you will see one CloudFormation stack for each service:We now have a CI & CD pipeline.ServiceWe use a bunch of AWS services to run our microservices.Amazon API GatewayAPI Gateway is a service that offers a configurable REST API as a service. You describe what should happen if a certain HTTP Method (GET, POST,PUT, DELETE, ...) is called on a certain HTTP Resource (e.g. /user). In our case, we want to execute a Lambda function if an HTTP request comes in. API Gateway also takes care of mapping input and output data between formats. The following figure shows how this looks like in the AWS Management Console for the Profile Service.The API Gateway is a fully managed service. You only pay for requests, no under/over provisioning, no boot time, no patching, no SSH, no load balancing. AWS takes care of all those aspects.Read more about API Gateway on our blogAWS LambdaTo run code in AWS Lambda you need to:use one of the supported runtimes (Node.js (JavaScript), Python, JVM (Java, Scala, ...).implement a predefined interface.The interface in abstract terms requires a function that takes an input parameter and returns void, something, or throws an error.We will use the Node.js runtime where a function implementation looks like this:exports.handler = function(event, context, cb) { console.log(JSON.stringify(event)); // TODO do something cb(null, {name: 'Michael'}); }; In Node.js, the function is not expected to return something. Instead, you need to call the callback function cb that is passed into the function as a parameter.The following figure shows how this looks like in the AWS Management Console for the profile service.AWS Lambda is a fully managed service. You only pay for function executions, no under/over provisioning, no boot time, no patching, no SSH, no load balancing. AWS takes care of all those aspects.Read more about Lambda on our blogAmazon DynamoDBDynamoDB is a Key-Value-Store or Document-Store. You can lookup values by their key. DynamoDB replicates across multiple Availability Zones (data centers) and is eventually consistent.The following figure shows how this looks like in the AWS Management Console for the authentication service.Amazon DynamoDB is a 99% managed service. The 1% that is up to you is that you need to provision read and write capacity. When your service makes more request than provisioned, you will see errors. So it is your job to monitor the consumed capacity to increase the provisioned capacity before you run out of capacity.Read more about DynamoDB on our blogRequest FlowThe three services work together in the following way:The user's HTTP request hits API Gateway. API Gateway checks if the request is valid — if so, it invokes the Lambda function. The function makes one or more requests to the database and executes some business logic. The result of the function is then transformed into an HTTP response by API Gateway.We now have an environment to run our microservices.Logs, Metrics, and AlertingA Blackbox is very hard to operate. That's why we need as much information from the inside of the system as possible. AWS CloudWatch is the right place to store and analyze this kind of information:Metrics (numbers).Logs (text).CloudWatch also lets you define alarms on metrics. The following figure demonstrated how the pieces work together.Operational insights that you get out-of-the-box:Lambda writes STDOUTand STDERR to CloudWatch logs.Lambda publishes metrics to CloudWatch about the number of invocations, runtime duration, the number of failures, etc.API Gateway publishes metrics about the number of requests, 4XX and 5XX Response Codes, etc.DynamoDB publishes metrics about consumed capacity, the number of requests, etc.The following figure shows a CloudWatch alarm that is triggered if the number of throttled read requests of the Location Service DynamoDB table is bigger or equal to one. This situation indicates that the provisioned capacity is not sufficient to serve the traffic.With all those metrics and alarms in place, we now can be confident that we receive an alert if our system is not working properly.SummaryYou can run a high-quality system on AWS by only using managed services. This approach frees you from many operational tasks that are not directly related to your service. Think of operating a monitoring system, a log index system, a database, virtual machines, etc. Instead, you can focus on operating and improving your service's code.The following figure shows the overall architecture of our system:Serverless or FaaS does not force you to use a specific framework. As long as you are fine with the interface (a function with input and output), you can do whatever you want inside your function to produce an output with the given input. Read more

Driving, Surviving and Thriving Industry Disruption With APIs

A simple online shopping task or purchase used to be extraordinary. That was yesterday’s news. Today companies such as Rogers Communications put live NHL game content in the hands of a mobile user; General Motors gives drivers the ability to start, stop and understand diagnostic information even when remote from the vehicle; and L’Oréal keeps retail partner and shopper loyalty high with fully-integrated product stock and pricing information.These user engagement experiences have lasting effects. They impact the way we live, work and compete. Companies are no longer being compared to the competitors within their own traditional boundaries, but to all organizations that are delivering a great customer experience.Continuous Innovation Through APIsWhat we have learned through industry disruption is that those who compete and are digital disruptors in existing or new industries find new ways to continually innovate. The newly released API research report, “APIs and the Digital Enterprise: From Operational Efficiency to Digital Disruption” uncovered key areas digital disruptors are investing in to adapt and thrive in the new application economy.1. Release engaging apps faster: To deliver optimal digital experiences businesses need to get apps out faster, understand usage sooner and iterate more often. It is not about delivering the most features but the right features in today’s experience driven world. 84 percent of organizations are using or planning to use APIs to speed delivery of revenue enhancing apps.2. Unlock data silos to improve customer experience: Businesses need to tap in to useful data that is often hidden away in silos, accessed very little or never at all. The ability to use information to deliver a more engaging experience across channels based on consumer insights provides a much more convenient and personalized experience that keeps customers coming back. 85 percent of organizations are using or planning to use APIs to deliver new and better customer experiences.3. Expand reach through digital ecosystems: Successful digital organizations must find a way to open up information and expand digital ecosystems. The ability to effectively share information will allow digital disruptors to extend reach and access entirely to new markets. Understanding how to connect and share data will enable companies to capitalize on the network effect ecosystems offer. 84 percent of organizations are using or planning to use APIs to extend their digital reach.L’Oréal: How APIs Drove Consumer Goods InnovationAs the world’s largest cosmetics company, L’Oréal is dedicated to beauty. L’Oréal sought to modernize on a single ecommerce platform in the Americas, with the ability to support any combination of digital, retail and partner channels through a consistent set of APIs. L’Oréal witnessed a 5X increase in the number of application connections without having to expand development teams. In addition, L’Oréal was also able to tap in to the value of customer data, combining it with merchandise to deliver a better customer experience. This took shape with the L’Oréal Makeup Genius app, which delivered an innovative omni-channel virtual experience of trying on makeup. Finally, L’Oréal was able to open and share product data with partners such as Target. This helped reduce operational costs, cutting down inventory overage, while ensuring shelves were filled with accurate pricing. This all was possible through APIs.Why API ManagementSuccessful organizations such as L’Oreal have found API Management necessary for their API projects. The right API Management solution should effectively allow organizations to create APIs and integrate with data, secure and mitigate the risk of APIs, accelerate the development of mobile and IoT apps connecting to APIs and unlock the value of data by engaging in new digital ecosystems. See www.ca.com/api to learn more how CA API Management can help. Read more

Democrat gun control sit-in sparks social media sensation

A blackout of television cameras in the U.S. House Representatives during the Democrats' gun control sit-in may have spurred public interest in the protest as it forced the demonstrators to use social media to broadcast their message.Democrats leapt on Facebook Live and Twitter's Periscope after the cameras, controlled by the House, went dark Wednesday when presiding House officer and Republican Representative Ted Poe declared the chamber not in order during the protest.As Democrats took to alternative forms of video broadcasting, their message gained tremendous momentum from social media. On Twitter, the hashtags #NoBillNoBreak and #HoldTheFloor have been tweeted at least 1.4 million times.Of the roughly 20 members of Congress who remained at the sit-in overnight, 19 of them used Facebook Live for a total combined viewership of 3 million.“It really connected with people out there,” Congressman Scott Peters told Reuters. "This whole phenomenon with [live video] struck a nerve."Peters used the application Periscope, which is connected to the social media platform Twitter, to send out video. “Without that, think about it, it would have been a caucus meeting where we talk to ourselves," he added. In remarks Wednesday outside the Capitol, House Democratic Leader Nancy Pelosi praised how her party harnessed social media."Without you and without the technology of Periscope [the sit-in] would just be a debate in the Halls of Congress unrecorded because they turned off the microphones," Pelosi said. "But we raised our voices. They turned off the cameras and we went to Periscope." Congressman Mark Takano, who began posting live videos from the chamber to his Facebook page Wednesday afternoon and continued to throughout the night, said the social media video helped him connect with constituents."Once I got started with the live streaming I didn’t feel like I could let down the people who were following me,” said Takano. “It was a way to push out a message.”Even C-SPAN, which typically broadcasts footage recorded by the House cameras, picked up live video from four different members of Congress roughly two hours after the House cameras shut down, according to communications director Howard Mortman. It marked the first time the channel broadcast a live social media feed from the House floor. "Something interesting is happening with Facebook Live that's bringing more openness to the political process," said Mark Zuckerberg, CEO of Facebook, in a post to his social media profile Thursday."It's a way to share anything you want with the world using just your phone." (Reporting By Amy Tennery; additional reporting by Angela Moon in New York and Susan Cornwell in Washington; Editing by Andrew Hay) Read more

Folding the Universe, Part II: Abstracting Recursion

This is a series of articles complementing my book, Functional Programming in Java. The previous article in this series may be found here:Folding the Universe, Part IIn the the previous article in this series, I showed how to write a functional Java program solving the Knapsack problem, which consists of packing a knapsack of a given capacity with items from a collection, while maximizing the knapsack's value, given that each item has a weight and an individual value. Of course, we must not exceed the knapsack capacity. This problem may be applied to dividing any quantity (the knapsack capacity) in parts (the items) while maximizing the value, which might, in some cases, mean minimizing the unused capacity (when the value of each item is proportional to its weight). There are indeed several variants of this problem, the most common two being packing with a single copy of each item and packing with as many copies as wanted of each item. An example of solving this problem in traditional imperative Java may be found here: Knapsack problem/0-1. Please have a look at it before reading this article.The ChallengeAs I said in the previous article, the challenge is to solve the problem while using no variables (only constants) and no control structures, but only using classes and methods, arithmetic operations and comparisons, and Java 8 Function and BiFunction. I showed a bi-recursive version in the previous article, and explained why it was not really usable (at least for lists of items longer that thirty elements). Our new challenge is to write this same program without using recursion at all, except for the folds, which are abstracted in the List class that we have defined. If you haven’t read part I, please do so before reading this article. (Folding the Universe, part I)How to Avoid RecursionTo avoid bi-recursion, we have to memorize the result of each step in order not not have to compute it again and again. It is obvious that when examining an item to see if we should put it in the knapsack, we must consider what we have already put into it in previous steps. What we will do is:Build a list of knapsacks of capacity varying from 1 to the given capacity, in reverse order.For each item in the list:Try to put it in all of the knapsacks. In the previous example, we tested the item weight to see if it would fit in the knapsack. Here, for each knapsack, we will first filter out the items which capacity exceeds the knapsack capacity.Find the knapsack corresponding to index (item.weight - 1) and add the item to it.Find the knapsack of maximum value and add it to the listFrom the resulting knapsack list, select the one with the maximum value. This is the result of the packing.Note that if we add a knapsack to the list, we put it in front of the list. So, the knapsack with the maximum value will simply be the head of the list. This is why we select the knapsack of index (item.weight - 1). This would correspond to an index of i - it.weight if the list was build the other way, where i would be the index of the knapsack we are in.Here is the corresponding code:public static Knapsack pack(List items, int capacity) { final Knapsack zero = empty(capacity); (1) final List result = List.range(capacity + 1, 1).foldRight(List.list(), (i, acc) -> { (2)(3) Knapsack knapsack = items.filter(item -> item.weight <= i) (4) .flatMap(item -> acc.at(item.weight - 1).map(k -> k.add(item))) (5) .foldRight(zero, Knapsack::maxValue); (6) return acc.cons(knapsack); (7) }); return result.head().foldRight(zero, (a, b) -> a); (8) }(1) A "zero" knapsack is created with the given capacity. This is just a convenience to avoid calling the Knapsack.empty() method several times.(2) A list of integers from the given capacity to 1 is built by calling the range method. This method must be added to the List class.(3) This list of integers is mapped to a list of knapsacks. While constructing this list (named acc, for "accumulator", by convention), the previously created knapsacks are available.(4) We filter the items so that we won’t try to insert items with a weight higher than what the knapsack may contain.(5) We look for a previously created knapsack of index item.weight - 1. The List.at(n) method has to be created and it will return optional data, which mean a list of zero (not found) or one (found) knapsack. If this knapsack is found, the item is added to it, which is done by mapping the function k → k.add(item) to the singleton knapsack list.(6) From the resulting list, we select the knapsack with the maximum value.(7) The resulting value is added to the (head of) accumulator. This concludes the function used for folding the list of integers, in (3).(8) Once the list of integers is folded to a list of knapsacks, we just have to select the maximum value, which is automatically the head of the list. As the head method returns a singleton list, we use a "getOrElse" technique to select either the value if it is present, or a default value if not.The technique used here is very well known in functional programming and is called memorization. It consists in keeping access to the previous results instead of recomputing them at each step. This technique is also used in imperative programming. The particularity of the functional programming version is the way the previous results are transported during the fold (in the acc parameter).Implementing the Missing MethodsIn this example, we have used two new methods that are missing in the List class. The range method is a convenience method allowing creating a list of integers from start (included) to end (excluded) if start is lower than end. Otherwise, the list is constructed in reverse order. The fact that start is included and end is excluded is purely conventional. Here is the corresponding implementation in the List class:public static List range(int start, int end) { return start < end ? rangeAsc(list(), start - 1 , end - 1) : rangeDesc(list(), end, start); } private static List rangeAsc(List acc, int start, int end) { return start == end ? acc : rangeAsc(new Cons<>(end, acc), start, end - 1); } private static List rangeDesc(List acc, int start, int end) { return start == end ? acc : rangeDesc(new Cons<>(start, acc), start + 1, end); }The List.at(n) method allows indexed access to the list. It is not very efficient, since it needs time proportional to n, but is is perfectly usable when n is low. Here is the implementation:public List at(int n) { return tail().flatMap(t -> n == 0 ? head() : t.at(n - 1)); }This method is even less efficient since it uses the head method defined in the previous article. We will fix this in the next section.Solving the Real ProblemBeside efficiency, we have a more important issue: our program does not solve our real problem, because it allows using several times the same item. It was done this way for simplification. Now, we can fix this easily:public static Knapsack pack(List items, int capacity) { final Knapsack zero = empty(capacity); final List result = List.range(capacity + 1, 1).foldRight(List.list(), (i, acc) -> { Knapsack knapsack = items.filter(item -> item.weight <= i) .flatMap(item -> acc.at(item.weight - 1).map(k -> k.contains(item) ? k : k.add(item))) (1) .foldRight(zero, Knapsack::maxValue); return acc.cons(knapsack); }); return result.head().foldRight(zero, (a, b) -> a); }(1) We put the element in the knapsack only if it has not yet been used, which simply means that the knapsack does not already contain it.To make this possible, we must add the contains method to the Knapsack class:private boolean contains(Item item) { return items.contains(item); }This method simply delegates to the List.contain(a) method. Guess what this method will be based on? Bingo! A fold:public boolean contains(A a) { return foldLeft(false, (result, b) -> a.equals(b) || result); }Again, this method is not optimized, since it will have to traverse the whole list instead of escaping as soon as a matching element is found.Note that we must define an equals method in our Item class. I will not show it here, since you certainly know how to do this. Moreover, any good IDE will generate it for you. However, to be really complete, we should add a unique ID to the Item class. Forgetting to do so will make it impossible to have two different items with the same weight and value in the list. A very simple way to do this, if the ID is not to be used for anything else, is to generate a UUID and use it for equality:public class Item { public final String name; public final int weight; public final double value; private final UUID id = UUID.randomUUID(); (1) private Item(String name, int weight, double value) { this.name = name; this.weight = weight; this.value = value; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Item item = (Item) o; return weight == item.weight && Double.compare(item.value, value) == 0 && (name != null ? name.equals(item.name) : item.name == null && id.equals(item.id)); (2) } ...A random UUID is generated, and it is used to test equality.Representing the Absence of DataIn this example, we had to represent data that could be present or absent. For example, a method returning the first element of a list could return nothing if the list is empty. Traditional languages use the null reference, invented by Sir Charles Antony Richard Hoare (a.k.a. "Tony Hoare"), which is what he called his "million dollars mistake". The null reference is the plague of programming because it does not compose. This is something it has in common with exceptions (to which it transposes very easily!). This does not mean it is not possible to compose it, but it does not compose transparently by itself. The programmer has to handle it separately through some control structures.In the previous article, we saw that it was perfectly possible to use a list to represent optional data. Absence of data is represented by an empty list, and data is represented by a singleton list. The main problem is that there was no mean to differentiate a normal list from a singleton list. The good thing is that it is very easy to compose both.Another possibility is to use a special class to represent singleton lists. We might call this class Option. It will be identical to the List class, with two main exceptions: there is no cons method (since we can’t add elements) and the folding methods generally do not take a function argument. It could however take one, but it would in most use cases be the identity function, which is why it is most often implemented without this function argument. This method will then simply return either the included value, if it is present, or the "zero" value if not. Of course, the "zero" value will have a more explicit name such as default, but this (like names in general) is irrelevant. Here is a minimal Option class:public abstract class Option { public abstract B foldRight(B identity, BiFunction f); public Option map(Function f) { return foldRight(none(), (a, option) -> some(f.apply(a))); } public Option flatMap(Function> f) { return foldRight(none(), (a, option) -> f.apply(a)); } public Option filter(Predicate p) { return foldRight(none(), (a, option) -> p.test(a) ? some(a) : none()); } public A getOrElse(A defVal) { return foldRight(defVal, (a, b) -> a); } private static class None extends Option { @Override public B foldRight(B identity, BiFunction f) { return identity; } public String toString() { return "None()"; } } private static class Some extends Option { private final A value; private Some(A value) { this.value = value; } @Override public B foldRight(B identity, BiFunction f) { return f.apply(value, identity); } public String toString() { return String.format("Some(%s)", value); } } @SuppressWarnings("rawtypes") private static Option NONE = new None(); @SuppressWarnings("unchecked") public static Option none() { return NONE; } public static Option some(A a) { return new Some<>(a); } }What Option Changes to Our ExampleUsing Option to represent optional data instead of a list brings some benefits in the sense that a program is often easier to read if we can easily distinguish between true lists (which can contain any number of elements) and singleton lists representing optional data (which can only contain zero or one element). By the way, the difference is not always visible, since type may sometimes be inferred, such as when chaining methods. Here is our pack method using Option instead of List for optional data:public static Knapsack pack(List items, int capacity) { final Knapsack zero = empty(capacity); final List result = List.range(capacity + 1, 1).foldRight(List.list(), (i, acc) -> { Knapsack knapsack = items.filter(item -> item.weight <= i) .sequence(item -> acc.at(item.weight - 1).map(k -> k.contains(item) ? k : k.add(item))) (1) .map(list -> list.foldRight(zero, Knapsack::maxValue)) (2) .getOrElse(zero); (3) return acc.cons(knapsack); }); return result.head().getOrElse(zero); (4) }(1) The flatMap method can’t be used, since it produces a List Here, we produce an Option, but this would not be visible if we had kept the name flatMap for the method. We will of course have to define the Option.sequence method.(2) The map method is called on an Option, but it is difficult to see by looking at the code!(3) Getting the value (if present) or a default value (if not) is done through the getOrElse method. We changed the name to follow conventional usage although it is implemented through a fold!(4) We can simplify getting the value or default value from the resulting Option.The map and getOrElse method can be seen in the previous listing of the Option class. You can see that Option is really a List. The problem happens when a list is mapped with a function returning an Option. When we were using a list for optional data, the function was returning a List, so we ended with a List>. Getting a List instead was just a matter of using flatMap instead of Map. With Option, we end with a List. So we have to create a method for this. We will put it in the List class. By convention, this method is called sequence. In order to better mimic the List.flatMap method, we will also add a convenience sequence method taking a function returning an Option as its argument:public Option> sequence(Function> f) { return sequence(map(f)); (1) } public static Option> sequence(List> list) { return list.foldRight(Option.some(List.list()), (oa, acc) -> map2(oa, acc, (a, b) -> b.cons(a))); (2) } public static Option map2(Option a, Option b, BiFunction f) { return a.flatMap(av -> b.flatMap(bv -> Option.some(f.apply(av, bv)))); (3) }(1) This method is a simple convenience allowing applying the function and calling sequence in a single operation that mimics the List.flatMap method.(2) The sequence method uses a foldRight (to preserve the list order) and a utility method map2 transforming a BiFunction into a BiFunction, Option, Option>(3) This is a very common idiom in functional programming. If you have trouble to understand it, you should insist until you succeed. It is not complicated. The first flatMap give access to the value contained in the first Option (av). The second nested flatMap does the same for the second Option, producing the value bv. We can apply the function to these two values, producing a C. As we want an Option, we just wrap it into an Option.Some.Note that the map2 implementation is not optimal. We must take the value out of the first Option, thus using flatMap. But we are not forced to do the same with the second. An alternate (and far more common) solution is to map the second option with the function:public static Option map2(Option a, Option b, BiFunction f) { return a.flatMap(av -> b.map(bv -> f.apply(av, bv))); }ConclusionWe have now completed our functional Knapsack example. If you compare to traditional imperative Java (for example Knapsack problem/0-1), you may think that the functional version is not shorter. This is true. You may also think it is not easier to understand. This is totally subjective. I found it cristal clear and I have trouble to understand the imperative version. But this is because I am used to functional programming, and I am reluctant to read imperative programs.So what are the benefits of the functional programming version? The main benefit is that we have abstracted a great deal of the program in classes (List and Option) that may be reused for solving other problems. Of course, Java has also List and Optional. Just try to write the same program with these classes and see for yourself. The real result is that beside the business code (the Item class and most of the Knapsack class), our program is less that ten lines long. As you know, the shortest the code, the fewer the bugs.Of course, there is plenty of room for optimization. We will look at some in a next article, while trying to solve a different problem. In the meantime, if you are interested in more advanced techniques about the subject, have a look at my book: Functional Programming in Java. Read more

Older PostNewer Post