[camel-website] branch master updated: Add blog of whats new in Camel 3

[da...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel-website.git


The following commit(s) were added to refs/heads/master by this push:
     new 383dd4d  Add blog of whats new in Camel 3
383dd4d is described below

commit 383dd4d472a6b2da8873e283256140c9a36fbecb
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Mon Dec 2 12:52:47 2019 +0100

    Add blog of whats new in Camel 3
---
 content/blog/Camel3-Whatsnew/camel3-3humps.png     | Bin 0 -> 84398 bytes
 .../blog/Camel3-Whatsnew/camel3-core-vs-engine.png | Bin 0 -> 22436 bytes
 content/blog/Camel3-Whatsnew/camel3-projects.png   | Bin 0 -> 88043 bytes
 content/blog/Camel3-Whatsnew/camel3-quarkus.png    | Bin 0 -> 737648 bytes
 content/blog/Camel3-Whatsnew/camel3-website.png    | Bin 0 -> 130976 bytes
 content/blog/Camel3-Whatsnew/index.md              | 171 +++++++++++++++++++++
 6 files changed, 171 insertions(+)

diff --git a/content/blog/Camel3-Whatsnew/camel3-3humps.png b/content/blog/Camel3-Whatsnew/camel3-3humps.png
new file mode 100644
index 0000000..e5bf73c
Binary files /dev/null and b/content/blog/Camel3-Whatsnew/camel3-3humps.png differ
diff --git a/content/blog/Camel3-Whatsnew/camel3-core-vs-engine.png b/content/blog/Camel3-Whatsnew/camel3-core-vs-engine.png
new file mode 100644
index 0000000..ef2959f
Binary files /dev/null and b/content/blog/Camel3-Whatsnew/camel3-core-vs-engine.png differ
diff --git a/content/blog/Camel3-Whatsnew/camel3-projects.png b/content/blog/Camel3-Whatsnew/camel3-projects.png
new file mode 100644
index 0000000..6c9e720
Binary files /dev/null and b/content/blog/Camel3-Whatsnew/camel3-projects.png differ
diff --git a/content/blog/Camel3-Whatsnew/camel3-quarkus.png b/content/blog/Camel3-Whatsnew/camel3-quarkus.png
new file mode 100644
index 0000000..a06a9db
Binary files /dev/null and b/content/blog/Camel3-Whatsnew/camel3-quarkus.png differ
diff --git a/content/blog/Camel3-Whatsnew/camel3-website.png b/content/blog/Camel3-Whatsnew/camel3-website.png
new file mode 100644
index 0000000..3cee196
Binary files /dev/null and b/content/blog/Camel3-Whatsnew/camel3-website.png differ
diff --git a/content/blog/Camel3-Whatsnew/index.md b/content/blog/Camel3-Whatsnew/index.md
new file mode 100644
index 0000000..20e5c50
--- /dev/null
+++ b/content/blog/Camel3-Whatsnew/index.md
@@ -0,0 +1,171 @@
+---
+title: "Apache Camel 3 Whats New (top 10)"
+date: 2019-12-02
+author: Claus Ibsen
+categories: ["Release"]
+preview: Top 10 of whats new in Apache Camel 3
+---
+
+Apache Camel 3 was released last thursday November 28th 2019, which also happens to be the day of the US Thanksgiving. This was not intentionally but we can say its a big thanks from us to the community with a brand new major version of Camel - this does not come often by. In fact its 10 years since Camel 2 hit the streets. So this 3rd generation is long overdue.
+
+{{< image "camel3-3humps.png" "Apache Camel 3" >}}
+
+
+This blog post highlights the noteworthy new features and improvements in Camel v3.
+
+### 1) Camel is now a family of projects
+
+Apache Camel, is now a family of projects (3 at this time of writing).
+- [Camel 3](https://github.com/apache/camel):
+  **Integration Framework** _Swiss knife of integration_
+- [Camel K](https://github.com/apache/camel-k/):
+  **Lightweight Serverless Integration Platform** _Camel on Kubernetes & Knative_
+- [Camel Quarkus](https://github.com/apache/camel-quarkus):
+  **Camel extensions for Quarkus** _Optimized JVM & Native compiled Java (GraalVM)_
+
+{{< image "camel3-projects.png" "Camel 3 projects" >}}
+
+The Camel code-base is very large, and we have setup sub-projects for new innovative projects using Camel. The first sub-project was to run Camel as cloud-native on Kubernetes in a serverless manner which became Camel K. Then Camel Quarkus came to make Java and Camel with very fast startup and very small memory footprint primary for container based deployments. 
+
+
+### 2) New Website
+
+{{< image "camel3-website.png" "Camel 3 website" >}}
+
+A major goal for Camel 3 was to finally revamp the old aging website to use modern technologies and be able to auto-generate content from the source code. This has taken years to get to this point as we have built tools over the last many Camel 2.x releases that could take us closer.
+At end of 2019 then the Camel community and others stepped up and provided the new art-work, logo, and look and feel for the new website - thank you very much!.
+
+For Camel 3.x we will continue to improve the website and the documentation. This is much easier for us to do, and also for people to contribute changes as its just a regular github PR to provide updates. We love contributions.
+
+Zoran had some fun with the new look and feel and he added a little gem; if you stare at the front page, then you should see a little animation of the curved bezel ;)
+
+
+### 3) Java 11
+
+Camel 3 is the first official release that supports Java 11. Java 8 will still be supported for the first number of 3.x releases, but is expected to be dropped later in 2020. However we wanted to provide Java 8 support to help migrate Camel 2.x users whom may be restricted to Java 8 for some time to come.
+
+
+### 4) Modularized camel-core
+
+The camel-core has been modularized from 1 JAR to 33 JARs. The core functionality has been splitup into:
+
+| JAR | JAR | JAR |
+|---- |---- |----
+| **camel-api** | camel-core-osgi | camel-management-api |
+| camel-base | camel-core-xml | camel-management-impl |
+| camel-caffeine-lrucache | camel-endpointdsl | **camel-support** |
+| camel-cloud | camel-headersmap | camel-util |
+| camel-core | camel-jaxp | camel-util-json |
+| camel-core-engine | camel-main | 
+
+For Camel end users then only a few JARs is relevant. **camel-api** contains the public API for Camel (eg interfaces such as CamelContext, Endpoint, Exchange, Message, and son on). **camel-support** contains the base classes and `RouteBuilder` which you would use to build Camel routes and applications. This JAR is also contains necessary base classes for building custom Camel components, and other kinds of plugins.
+
+The components that resided in camel-core has also be externalized into individual components:
+
+| JAR | JAR | JAR |
+|---- |---- |----
+| came-bean | camel-log | camel-stub |
+| camel-browse | camel-mock | camel-timer |
+| camel-controlbus | camel-properties | camel-validator |
+| camel-dataformat | camel-ref | camel-vm |
+| camel-direct | camel-rest | camel-xpath |
+| camel-directvm | camel-saga | camel-xslt | 
+| camel-file | camel-scheduler | camel-zip-deflater |
+| camel-language | camel-seda | |
+
+Camel end users can then pick and choose exactly only what they need, or keep using everything.
+
+Therefore we have `camel-core` and `camel-core-engine` as two starting dependencies.
+You can use `camel-core` which gives you all the JARs which is similar to Camel 2.x.
+When you use `camel-core-engine` you get the minimum set of JARs that makes a functional Camel.
+
+{{< image "camel3-core-vs-engine.png" "Camel 3 core vs engine" >}}
+
+`camel-core` contains 33 JARs and `camel-core-engine` contains 12 JARs.
+
+
+### 5) Faster startup and lower footprint
+
+We have reduced the size of core Camel and the number of classes loaded. For example in Camel 2 about 5200 classes was loaded, which has been reduced to about 4300 loaded classes in Camel 3.
+
+We have also done many smaller optimizations in the core, to reduce the number of allocated Java objects, and speeup initialization and other means. We have used JVM profiling tools to assist and find the bottlenecks.
+
+Another area of improvement is to reduce Java reflections. In Camel 2 then all the configuration of Camel components, endpoints, and routes are reflection based. In Camel 3
+we have source code generated Java code for configuration that allows us to use direct Java calls instead of reflections. 
+
+Another similar area is Camel's type converters which in Camel 2 are Java reflection based (you could build custom type converts that was not reflection based. In Camel 3 we also generate Java source code which means that type converting is direct Java calls at runtime.
+
+We have also moved initialization logic to earlier phases when it was possible. For example there is a new build phase which allows Camel to do special initialization during building your project (this requires Camel Quarkus).
+
+All this optimization improves the startup performance of Camel and reduces the memory overhead. With Camel Quarkus you can native compiled your Camel application and make it startup in 30 milli seconds and consume only 10mb of memory (RSS) with a full blow HTTP REST server and health-checks and metrics.
+
+{{< image "camel3-quarkus.png" "Camel 3 Quarkus native compiled" >}}
+
+There are still a few items still on the agenda that we want to work on in Camel 3.x to further optimize Camel core.
+
+
+### 6) Type Safe Endpoint DSL
+
+Camel end users whom has configured endpoints using URI strings, would all have experience the problem when you make a configuration mistake in the endpoint, which then makes Camel fail on startup.
+
+In Camel 3, we have a new type-safe DSL for endpoints which you can use in Java routes.
+You can continue to use the classic URI strings, but if you want to try the endpoint DSL, then you need to add `camel-endpointdsl` to your classpath. Then you should extend `EndpointRouteBuilder` instead of `RouteBuilder` to access the endpoint DSL.
+
+Here is a basic example without and with the endpoint DSL:
+
+```
+from("timer:click?period=3000&fixedRate=true")
+    .to("seda:foo?blockWhenFull=true");
+
+from(timer("click").period(3000).fixedRate(true))
+    .to(seda("foo").blockWhenFull(true));
+```
+
+You can also find a [little example](https://github.com/apache/camel/tree/master/examples/camel-example-cafe-endpointdsl) in the source code.
+
+
+### 7) Reactive Routing Engine
+
+The routing engine in Camel has internally been reactive'fied and all EIPs has been retrofitted to work in a reactive manner. However this is internal only, and the Camel API for both end users and component developers are based on existing callback behavior.
+
+We will later introduce and work on a client-side facing reactive API after we have jumped to Java 11 as minimum version (then we can support Java 9 flowable API). 
+
+Camel already have integration with reactive frameworks such as Vert.X, RxJava and Reactor Core in the dedicated Camel components.
+
+
+### 8) Camel Main
+
+We have introduced `camel-main` as a standalone JAR that makes it easier to run just Camel.
+There are a [couple of examples](https://github.com/apache/camel/blob/master/examples/camel-example-main/readme.adoc) with the source code that demonstrates how to do that.
+
+We also use `camel-main` to have common code to configure and bootstrap Camel for standalone, Spring Boot, Camel K, and Camel Quarkus. This allows us to share the same code, and configuration options.
+
+
+### 9) Camel Microprofile
+
+Camel 3 now integrates better with Eclipse Microprofile and we have Camel components for Microprofile configuration, metrics, health checks, and fault tolerance (on the way).
+
+More components to come in upcoming Camel releases. These microprofile components are also used by Camel Quarkus.
+
+
+### 10) Miscellaneous improvements
+
+Camel 3 now supports JUnit 5 for unit tests, with the test components that has -junit5 as suffix.
+
+The Camel `Registry` is now also writeable, so you can add beans to the registry at runtime, or from unit tests etc.
+
+You can also configure endpoints (producer) to lazy start. By default Camel works in a fail-fast mode, which means that Camel components that fails to connect to external systems during startup may cause the route to fail on startup. For Camel 3 you can now configure these endpoints to lazy start, which means the route will startup and they will first fail when a message is routed to the endpoint.
+
+Camel also allows to configure your routes to be supervised during startup, which allows Camel to more intelligently start routes in a more safe manner, by restarting routes that failed.
+
+
+### 11) Migrating to Camel 3
+
+We have of course cleaned up the code base, such as removing all deprecated APIs and components. We have also adjusted some APIs to make them easier to use from end users, and more Java 8 lambda friendly.
+
+Internally we have also adjusted the route model, to make it easier to extend into new DSLs; and there is a YAML DSL on the way which was initiated in Camel K.
+
+In terms of backwards compatibility then Camel 3 is mostly compatibility for regular Camel applications. However if you are using some of the more advanced and other plugins in Camel then migration is needed. Also custom components must be migrated and recompiled. There are other adjustments such as Spring Boot users must use `org.apache.camel.springboot` as groupId instead of `org.apache.camel` etc. All details can be seen in the [migration guide](https://camel.apache.org/manual/latest/ [...]
+
+
+Good luck with your migration if you decide to continue your Camel journey. And for new users to Camel then good luck getting onboard.
\ No newline at end of file