Eclipse IDE for Java

logi.CLOUD is an innovative and cloud-based engineering platform for industrial controllers. The project is based on Eclipse Theia and adopts several other Eclipse technologies, such as Eclipse GLSP and Xtext. In this article, we will take a ... [More] detailed look at this adopter project, its use case and how the Eclipse ecosystem and the adopters mutually benefit from each other. “This is one of my favorite adopter projects,” said Thomas Mäder (Theia project lead), about logi.CLOUD when he recently presented the huge variety of Theia adopters. The reasons are simple. logi.CLOUD solves a very interesting and challenging use case by combining powerful technologies into a modular tool chain. By adopting modern web-based UI technologies, the tool offers a fresh and slick look-and-feel. Furthermore, the project has been a strong contributor to the ecosystem since its inception. About logi.cals logi.cals, the company behind logi.CLOUD, has a strong track record in building engineering platforms for industrial automation, ranging back to the mid 1980s, when logi.cals delivered their first version of logi.CAD to customers. Since then, logi.CAD has been continuously evolving to always meet the adapting requirements in the market. logi.CAD is a powerful and feature-rich industrial automation engineering platform supporting the IEC 61131-3 standard and combining it with support for C for programmable logic controllers. In combination with their portable runtime system, named logi.RTS, several thousands of engineers world-wide use logi.CAD to automate complex systems, such as hydroelectric power plants, steel mills, buildings, ships, and much more.  About logi.CLOUD logi.CLOUD is the next generation engineering platform by logi.cals that enables an entirely browser-based industrial automation engineering based on IEC 61131-3. Together with other innovative components of the Open Automation Architecture solutions by logi.cals, the entire development process, including orchestration, configuration, testing, versioning, and deployment can be used as a cloud service for automation engineers or can be integrated seamlessly into an end-to-end solution provided by control and component manufacturers (OEMs and ODMs) for their customers. Therefore, one of the key characteristics of logi.CLOUD is to be extensible and open for customization, e.g. for adding programming support for other programming languages, integrating OEM-specific deployment services or functionality, etc. Users of the logi.CLOUD engineering tool ultimately benefit from a modern and easily accessible engineering application with high-end programming support, such as code completion, validation, navigation, graphical diagram editing, debugging, etc. The programming support is not only available for the IEC 61131-3 languages, such as Structured Text, Function Block Diagrams, and Ladder, but also for other programming languages, such as C and C++, which can be used with the logi.cals runtime systems too. The IEC 61131-3 editing and code generation features are provided by the mature components from logi.CAD 3, integrated into logi.CLOUD as a language server. The editors for the graphical languages, such as Function Block Diagrams and Ladder, are built based on Eclipse GLSP. C and C++ support is provided by the popular clangd language server. In the following screenshots, you can see some of the features of logi.CLOUD to gain an impression of the tool.   logi.cloud Engineering Tool: Program instances, ST editor and FBD editor (based on the Theia workbench)   logi.CLOUD Engineering Tool: Code completion, validation (dark theme) (based on Xtext and Eclipse Theia theming support) logi.CLOUD Engineering Tool: Graphical editing of Function Block Diagrams (based on Eclipse GLSP)   logi.CLOUD Engineering Tool: Navigation across Structured Text and Function Blocks (based on Eclipse GLSP and a custom Theia extension) logi.CLOUD Engineering Tool: Live data for debugging in Function Blocks and Structured Text (based on the DAP support in Eclipse Theia and Eclipse GLSP) logi.CLOUD and Eclipse Theia Extensibility and openness is where Theia really demonstrates all its power and proves to be a great platform choice for logi.CLOUD. The Theia platform, and thus logi.CLOUD, can be easily enhanced with additional language support via the language server protocol, extended with existing VSCode plugins, and even deeply customized and streamlined for specific OEMs or use cases due to the powerful Theia extension API (see here for a comparison of Theia extension mechanisms). logi.cals had already been an adopter of the Eclipse ecosystem  for desktop-based tooling when web- and cloud-based tooling started to come up. With logi.CLOUD they started to be an early adopter of these new technologies from Eclipse and also from outside of the ecosystem. Being an early adopter always provides some challenges, but also provides the opportunity to be a core innovator in a domain. The development of logi.CLOUD strategically includes open source technologies. The open source strategy enables logi.CLOUD to reduce the development effort and maintenance costs as well as benefiting from the ongoing innovation in the Eclipse ecosystem. However, logi.cals is not just an adopter. Understanding the strategic value of a working ecosystem, and the benefits of taking influence, logi.cals is a continuous contributor to the respective open source ecosystem. logi.CLOUD has even shared their experiences with the community, e.g. by talking about it at EclipseCon. Therefore, logi.CLOUD is a “favorite project” not only because it is such an interesting domain but also because it is a great success story of industrial open source adoption. Projects like this not only benefit from the ecosystem, but strengthen it at the same time. We hope you enjoyed this adopter story. Get in contact with us if you want your tool adopting Eclipse Cloud Development Tools technologies as well! Testimonial Heinrich Steininger, CTO, logi.cals GmbH “My goal since the founding of our company has been to develop software tools that empower automation engineers in becoming more efficient and productive. The Eclipse ecosystem now allows us to make our development tools available for future cloud-based platforms to improve collaboration and facilitate domain integration. Working closely and productively with EclipseSource, we benefit from innovative Eclipse technologies and at the same time from well-established processes for open-source governance.” [Less]

The upcoming Eclipse Ditto version 2.4.0 will add support for W3C WoT (Web of Things) integration by referencing WoT Thing Model in Ditto managed twins describing the Things’ capabilities. By integrating WoT, Ditto takes a big step forward towards: ... [More] increased interoperability introspection of twins to find out their capabilities which properties are provided and their data type and format which actions can be invoked on the devices, including their expected input/output data type and format which events the devices are able to emit, including their data type and format addition of semantic context to Ditto managed digital twins and their capabilities description of Ditto twin HTTP APIs in an open, established, well specified, “web optimized”, active IoT standard backing Ditto managed twins with WoT models, also supporting “brownfield” setups, without the need for actual devices to be aware of WoT opening the door to a new ecosystem of tools To learn more about WoT (Web of Things), please visit: Web of Things in a Nutshell WoT integration in Ditto The WoT integration in Ditto covers several aspects: referencing HTTP(s) URLs to WoT Thing Models in Thing Definitions and in Feature Definitions generation of WoT Thing Descriptions for Thing and Feature instances based on referenced Thing Models resolving potential extensions via tm:extends and imports via tm:ref resolving potential Thing level compositions via tm:submodel resolving potential TM placeholders upon creation of new Things, generation of a “JSON skeleton” following the WoT Thing Model, including referenced TM submodels as Features of the Thing For additional details about the WoT integration, please check the full WoT integration documentation. The WoT integration is still marked as “experimental” as the WoT Thing Description version 1.1 is not yet published as “W3C Recommendation” and may still change - as well as the implementation of the standard in Ditto. Note: In order to enable the experimental support for WoT in Ditto 2.4.0, please configure the environment variable DITTO_DEVOPS_FEATURE_WOT_INTEGRATION_ENABLED to true. Example For a full example of the different aspects of the WoT integration, please check the full WoT integration example. To summarize: “link” a Thing with a public available WoT Thing Model by specifying the URL in its Thing Definition. creation of a new Thing can use a Thing Model (e.g. the example model https://eclipse.github.io/ditto-examples/wot/models/floor-lamp-1.0.0.tm.jsonld) in order to generate a JSON skeleton: curl --location --request PUT -u ditto:ditto 'http://localhost:8080/api/2/things/io.eclipseprojects.ditto:floor-lamp-0815' \ --header 'Content-Type: application/json' \ --data-raw '{ "definition": "https://eclipse.github.io/ditto-examples/wot/models/floor-lamp-1.0.0.tm.jsonld" }' which results in a Thing like this: { "thingId": "io.eclipseprojects.ditto:floor-lamp-0815", "policyId": "io.eclipseprojects.ditto:floor-lamp-0815", "definition": "https://eclipse.github.io/ditto-examples/wot/models/floor-lamp-1.0.0.tm.jsonld", "attributes": { "manufacturer": "", "serialNo": "" }, "features": { "Spot1": { "definition": [ "https://eclipse.github.io/ditto-examples/wot/models/dimmable-colored-lamp-1.0.0.tm.jsonld", "https://eclipse.github.io/ditto-examples/wot/models/colored-lamp-1.0.0.tm.jsonld", "https://eclipse.github.io/ditto-examples/wot/models/switchable-1.0.0.tm.jsonld" ], "properties": { "dimmer-level": 0.0, "color": { "r": 0, "g": 0, "b": 0 }, "on": false } }, "Spot2": { "definition": [ "https://eclipse.github.io/ditto-examples/wot/models/dimmable-colored-lamp-1.0.0.tm.jsonld", "https://eclipse.github.io/ditto-examples/wot/models/colored-lamp-1.0.0.tm.jsonld", "https://eclipse.github.io/ditto-examples/wot/models/switchable-1.0.0.tm.jsonld" ], "properties": { "dimmer-level": 0.0, "color": { "r": 0, "g": 0, "b": 0 }, "on": false } }, "Spot3": { "definition": [ "https://eclipse.github.io/ditto-examples/wot/models/dimmable-colored-lamp-1.0.0.tm.jsonld", "https://eclipse.github.io/ditto-examples/wot/models/colored-lamp-1.0.0.tm.jsonld", "https://eclipse.github.io/ditto-examples/wot/models/switchable-1.0.0.tm.jsonld" ], "properties": { "dimmer-level": 0.0, "color": { "r": 0, "g": 0, "b": 0 }, "on": false } }, "ConnectionStatus": { "definition": [ "https://eclipse.github.io/ditto-examples/wot/models/connection-status-1.0.0.tm.jsonld" ], "properties": { "readySince": "", "readyUntil": "" } }, "PowerConsumptionAwareness": { "definition": [ "https://eclipse.github.io/ditto-examples/wot/models/power-consumption-aware-1.0.0.tm.jsonld" ], "properties": { "reportPowerConsumption": {} } }, "SmokeDetection": { "definition": [ "https://eclipse.github.io/ditto-examples/wot/models/smoke-detector-1.0.0.tm.jsonld" ] }, "Status-LED": { "definition": [ "https://eclipse.github.io/ditto-examples/wot/models/colored-lamp-1.0.0.tm.jsonld", "https://eclipse.github.io/ditto-examples/wot/models/switchable-1.0.0.tm.jsonld" ], "properties": { "color": { "r": 0, "g": 0, "b": 0 }, "on": false } } } } the WoT Thing Description of Things containing a Thing Model in their "definition" may then be retrieved by invoking the existing endpoint GET /api/2/things/ with the Accept header application/td+json: curl --location --request GET -u ditto:ditto 'http://localhost:8080/api/2/things/io.eclipseprojects.ditto:floor-lamp-0815' \ --header 'Accept: application/td+json' Features of Things are handled as WoT “submodels” and also can describe themselves with the same approach, e.g.: curl --location --request GET -u ditto:ditto 'http://localhost:8080/api/2/things/io.eclipseprojects.ditto:floor-lamp-0815/features/Spot1' \ --header 'Accept: application/td+json' Ditto WoT Java model As part of the integration of WoT in Ditto, a Java module has been added to provide a Java API for the WoT “Thing Description”/”Thing Model” and their parts - this module can also be used separately from Ditto in order to e.g. have a builder based API for building new objects or to read a TD/TM from a string: org.eclipse.ditto ditto-wot-model ${ditto.version} Please have a look at the added ditto-wot-model module to find out more about example usage. Feedback? Please get in touch if you have feedback or questions towards this new functionality. – The Eclipse Ditto team [Less]

The Eclipse Foundation supports Ukraine in the face of Russia’s invasion, an unprovoked act of aggression on a peaceful neighbor.   This war directly impacts over 30 Eclipse Foundation committers who live and work in Ukraine. Many of them work on ... [More] the Eclipse Che project, which was named after the city of Cherkasy, where many of them reside. Sadly, Cherkasy is one of the many Ukrainian cities that have been attacked. Our thoughts are with our colleagues in Ukraine, along with all those impacted. We hope you and your families are safe and that this invasion comes to an end quickly.  In the short term, the cessation of war and a return to peace in Ukraine is paramount. In the longer term, it is our hope that peace and prosperity will soon flourish again.  We #StandWithUkraine [Less]

We are happy to announce the Eclipse Theia 1.23 release! This monthly release contains an amazing number of 59 merged pull... The post Eclipse Theia 1.23 Release: News and Noteworthy appeared first on EclipseSource.

Solving a problem with multiple languages and libraries can sometimes bring new insights.Challenge Yourself and Others to LearnI accepted a JLDD (Jet Lag Driven Development) challenge recently to implement a Wordle Checker Kata in Java. My friend ... [More] José Paumard sent me this challenge and I set out to solve it using my favorite Java collections framework — Eclipse Collections. I wrote a blog about the challenge and my Java / Eclipse Collections solution.A Wordle JLDD Kata ChallengeJosé then published his response in a great JEP Café tutorial video which he tweeted about. — @JosePaumardI really enjoyed the video and learned an approach to solving this problem using pattern matching that I wouldn’t have thought of on my own.I had come up with three slight variations on the same solution using Java with Eclipse Collections, and thought it might be interesting to try and build a solution using Pharo Smalltalk. So of course I built one, and tweeted about it. — @TheDonRaabSmalltalkers will hopefully recognize the emoji picture I used. It is the basic syntax of a lambda in Smalltalk — [|]. Parameters go on the left side of the pipe, and statements/expressions go on the right.A few days after posting this, I posted a slight variation on the Smalltalk solution. I have included both Smalltalk solutions in the blog along with three Java / Eclipse Collections solutions.My Smalltalk SolutionsI used Pharo 8.0 to implement my Smalltalk solution. First, I wrote the set of test assertions in a WordleTest class. Each assertion creates an instance of a Wordle class with a hidden word, and then calls a method named guess: which will output the expected result of the two words matched.SUnit Test assertions for the Smalltalk version of the Wordle Checker KataI created a Wordle class with an instance variable named hidden, and then added a method named guess: which takes a String parameter.As you read my Smalltalk solutions, I would note the following. Smalltalk has a very simple and powerful programming paradigm which leads to a very minimal syntax with only five reserved words (true, false, nil, self, super) in the language. There are no control statements (if, for, while) in Smalltalk , and everything is accomplished by sending messages to objects. The equivalent of if statements, for loops, while loops, etc. in other languages are accomplished by sending messages to different objects. Much of this is accomplished by passing lambdas around to methods as parameters, or calling appropriate methods on lambdas.Smalltalk Solution #1I wrote my first Smalltalk solution for guess: using with:do: and with:collect: methods. This solution passes all of the tests above.Smalltalk implementation of the guess method on a Wordle classThe with:do: and with:collect: methods are available on the SequenceableCollection class in Smalltalk. In Smalltalk, a String is a SequenceableCollection. The following is a view of the Smalltalk Collection hierarchy.Smalltalk Collection hierarchyThe method named with:do: lets you iterate over two String instances at the same time. The first argument passed is the the String that you want to iterate over with this String, and the second argument is a two argument lambda which doesn’t return anything (equivalent of a Procedure2 or BiConsumer in Java). This let me compare letters at the same index, exclude all of those that were equal and add the remaining letters to the Bag named remaining, which I initialized on the first line of the method. For anyone unfamiliar with the Bag data structure, a Bag is an unordered collection that allows duplicates. Nikhil Nanivadekar wrote a blog about the Bag data structure in Eclipse Collections which explains how it is implemented.The second method, with:collect:, is similar to with:do: in that it iterates over both String instances together. The difference is that the two argument lambda that is passed as the second argument is used as a Function2 (a two argument Function or BiFunction in Java) to transform the characters to a new String. The transformation will result in either an uppercase letter, a lowercase letter or a “.” being returned for each combination of letters.The ifTrue:ifFalse: method is a method on the Boolean class in Smalltalk and is overridden by the True and False subclasses. The method takes two lambdas as arguments. Depending on whether the Boolean is true or false, one of the two lambdas will be evaluated. The = method tests for equality and will return true or false. The literal true is the single instance of the class True , and false is an instance of False. I always thought it was kind of clever how Smalltalk implemented if control flow logic without using statements.Finally, the remove:ifAbsent: method is available on most Collection classes in Smalltalk, and in this instance I am calling this method on a Bag. The result of the method is to return the object that is removed, or if the object is not in the collection, evaluate and return the result of the lambda.Smalltalk Solution #2For the second Smalltalk solution, I had hoped to find a method named with:reject:, but unfortunately, no such method exists today. I could have added the myself, but instead I decided to use a method that was already implemented. I used withIndexSelect: as a somewhat more awkward alternative to with:reject: but at least more terse alternative to using with:do:. I also formatted the code for with:collect: using the recommended auto-formatting in Pharo. It should make it easier to read and is a good way to break up the ifTrue:ifFalse: message send with the nested lambdas.Smalltalk implementation of the guessWithIndex method on a Wordle classThe withIndexSelect: method is passed each character in the hidden String along with its corresponding index in the String. Indexes in Smalltalk are one based, so start at 1, not 0. This can’t be seen in this particular code example, but I think it’s an interesting difference between Smalltalk and Java. I look up the character at the same index position in the guess String using the at: method. Because I am using select: (inclusive filter) and not reject:(exclusive filter), I have to negate the comparison. I use ~= to compare the two letters, which translates to “not equal” in Smalltalk. Finally, I convert the resulting String instance from the call to withIndexSelect: to a mutable Bag. The rest of the solution is identical to my first Smalltalk solution.My Eclipse Collections SolutionsAll of my Java solutions used features of the Eclipse Collections library. All three solutions used Strings.asChars(string) to provide access to the primitive collection API. In Eclipse Collections, this static method returns a CharAdapter instance wrapping the String.Two of the three Eclipse Collections solutions use methods that end in WithIndex. The third solution uses a method named zipChar which allows two primitive collections to be zipped together into char pairs. The basic strategy is pretty much the same between my three solutions, with minor differences in implementation. Create a Bag of characters that do not have direct positional matches between both String instances (hidden and guess) Collect up one of three possible states for each character as a result String. Convert exact positional letter matches to uppercase, letter match in different position to lowercase, and no letter match to a “.” Eclipse Collections Solution # 1The first solution I wrote using injectIntoWithIndex and collectWithIndex. I wrote the original Wordle JLDD Kata Challenge blog with this solution included. You can read the blog for more details on the solution.Eclipse Collections solution using injectIntoWithIndex and collectWithIndexThe thing that bothered me most about this solution is that Eclipse Collections did not yet have rejectWithIndex available on primitive collections. The solution using injectIntoWithIndex is really implementing the rejectWithIndex pattern.Eclipse Collections Solution #2I have recently contributed selectWithIndex and rejectWithIndex methods to primitive collections in Eclipse Collections. The same methods existed on the object collection API in Eclipse Collections since the 11.0 release. I used rejectWithIndex in my second solution, along with the collectWithIndex approach used in Eclipse Collections Solution #1.Eclipse Collections solution using rejectWithIndex and collectWithIndexThe rejectWithIndex method here takes a target collection to store the results in.Eclipse Collections Solution #3My third Eclipse Collections solution using zipChar and collectChar was inspired by an alternative zipChar solution written by Vladimir Zakharov.The method zipChar creates a List of character pairs between both String instances. I reject the exact positional matches between char pairs and collect those char values into a MutableCharBag. Then I collect char values into a String based on the algorithm described above.From Wordle Kata Solutions to EC Integration TestThe Eclipse Collections Wordle Kata solutions I came up with are good examples of using some of the String iteration patterns available in the library. Because I am leveraging multiple String iteration patterns, I thought it made sense to turn the kata solutions into an integration level test for Eclipse Collections. I committed a new WordleTest class into Eclipse Collections along with my contribution of the primitive versions of selectWithIndex and rejectWithIndex. Below is the source code for the test.eclipse-collections/WordleTest.java at master · eclipse/eclipse-collectionsComparing the solutionsHere is a visualization of the intersection and set of differences between the methods available in Smalltalk and Eclipse Collections to solve this particular kata challenge.Intersection and Differences between Smalltalk and Eclipse Collections methodsI quite liked the with:do: and with:collect: methods in Smalltalk. I would have preferred to have a with:reject: method for this particular use case. While I could have added this method on my own to SequenceableCollection, it would be nice if it was part of the standard library. However, I doubt that this particular use case will be incentive enough to have it added. The following are the methods using with: as a prefix that are available on SequenceableCollection.It was interesting to see that there is a withIndexSelect: method in Smalltalk which is a slight difference in name to the equivalent of the selectWithIndex method in Eclipse Collections. There is no equivalent of rejectWithIndex, which is my preference in this use case. The methods collectWithIndex: and withIndexCollect: both exist in Pharo Smalltalk and are synonyms. It appears the naming preference is now in favor of withIndex as a prefix for these methods.The preference for withIndexCollect: over collectWithIndex: in Pharo SmalltalkThe method zipChar in Eclipse Collections has no equivalent in Pharo Smalltalk today. There is also no equivalent of asLazy either. Most iteration methods on the Smalltalk Collection classes are eager.In terms of elegance, I think the with:do and with:collect: methods worked the best for this use case. Again, it would have been slightly simpler and clearer if there was a with:reject: method.In terms of flexibility, I think the withIndex solutions are better than both the other solutions. Since you have the index, you can do whatever you need with it. For example, this would allow you to iterate over as many collections simultaneously as you need.In terms of fluency and ease of writing, I really liked the asLazy plus zipChar solution which could then just use reject, collectChar and toBag.Here’s a link to the tweet where Vladimir Zakharov shared his zipChar solution using Eclipse Collections. — @zakhavSummaryLearning multiple programming languages and libraries and using them to solve various coding katas can help you improve as a programmer. I think it’s interesting to see how languages and libraries compare and how they evolve over time. I don’t recall the methods I used in Pharo Smalltalk being available in VisualAge for Smalltalk when I programmed in it in the 1990s. This is a good sign, as it means the language and core libraries are still evolving. Similarly, the Eclipse Collections library continues to evolve as Java does, and new methods like selectWithIndex and rejectWithIndex now available on both object and primitive collections are a good example of this.Thank you for reading! I hope you enjoyed this Wordle JLDD Kata Challenge comparison with Smalltalk and Eclipse Collections.I am a Project Lead and Committer for the Eclipse Collections OSS project at the Eclipse Foundation. Eclipse Collections is open for contributions. If you like the library, you can let us know by starring it on GitHub. [Less]

Original post On behalf of the Eclipse JKube team and everyone who has contributed, I'm happy to announce that Eclipse JKube 1.7.0 has been released and is now available from Maven Central.Thanks to all of you who have contributed with issue ... [More] reports, pull requests, feedback, spreading the word with blogs, videos, comments, etc. We really appreciate your help, keep it up! What's new?Without further ado, let's have a look at the most significant updates: Improvements to the Gradle plugins preview features Support for more frameworks Improved Enricher support Better documentation Prometheus and Jolokia agents can be completely disabled � Many bug-fixes and improvements Using this releaseIf your project is based on Maven, you just need to add the kubernetes maven plugin or the openshift maven plugin to your plugin dependencies:<plugin> <groupId>org.eclipse.jkubegroupId> <artifactId>kubernetes-maven-pluginartifactId> <version>1.7.0version> plugin>If your project is based on Gradle, you just need to add the kubernetes gradle plugin or the openshift gradle plugin to your plugin dependencies:plugins { id 'org.eclipse.jkube.kubernetes' version '1.7.0' } How can you help?If you're interested in helping out and are a first time contributor, check out the "first-timers-only" tag in the issue repository. We've tagged extremely easy issues so that you can get started contributing to Open Source and the Eclipse organization.If you are a more experienced developer or have already contributed to JKube, check the "help wanted" tag.We're also excited to read articles and posts mentioning our project and sharing the user experience. Feedback is the only way to improve.Project Page | GitHub | Issues | Gitter | Mailing list | Stack Overflow [Less]

I am happy to announce that John Kellerman has joined the Eclipse Foundation as Community Manager for the Cloud DevTools Working Group. The Eclipse Cloud DevTools Working Group provides a vendor-neutral ecosystem of open-source projects focused on ... [More] defining, implementing and promoting best-in-class web and cloud-based development tools. As Community Manager, John will help drive the evolution and broad adoption of emerging open source solutions for cloud-based development tools including Eclipse Theia, Eclipse Che and the Open VSX Registry. John is based in Chapel Hill, North Carolina. He joins the Eclipse Foundation after retirement from IBM, and more recently consulting with the Eclipse Foundation on the Open Research initiative. At IBM, John was most recently a development manager within the Watson organization.  Previously, he was IBM’s representative to the Eclipse Foundation Board, and worked within IBM to support teams that leveraged the Eclipse IDE. John was part of the team that started the original Eclipse open source project and Foundation. Please join me in welcoming and congratulating John on taking on this new role in the Eclipse Cloud DevTools community!   [Less]

The Jakarta EE community is completely focused on execution of the Jakarta EE 10 release plan. Following the Jakarta EE Specification Process we are seeing the progress of the individual specifications. The Release Review is now completed for the ... [More] following specifications Jakarta Activation 2.1 - https://github.com/jakartaee/specifications/pull/427 Jakarta Annotations 2.1 - https://github.com/jakartaee/specifications/pull/437 Jakarta Mail 2.1 - https://github.com/jakartaee/specifications/pull/428 The other specifications that are ready for the Jakarta EE 10 release as they are service releases only are the following: Jakarta Bean Validation 3.0.1 Jakarta Dependency Injection 2.0.1 Jakarta Transactions 2.0.1 We are expecting more progress in the upcoming weeks! Stay tuned, or monitor progress on individual specifications release reviews! [Less]

BRUSSELS – February 24, 2022 – The Eclipse Foundation, one of the world’s largest open source foundations, along with the Eclipse IoT Working Group, today announced a new project with initial contribution from Bosch.IO that is designed to address the ... [More] ever-growing complexity in edge computing environments, as well as a growing need for support for the Artificial Intelligence of Things (AIoT). Eclipse Kanto™ is a lightweight, modular software stack that runs on edge devices and enables them with all the essentials for IoT environments - cloud connectivity and digital twins, local messaging, container management and software updates - all configurable and remotely manageable by an IoT cloud ecosystem of choice.  “As organizations turn towards more complex devices at the edge, there is a growing need to ensure these devices already have the fundamental functionality required, allowing developers to focus on their value-add rather than re-creating the wheel,” said Mike Milinkovich, Executive Director of the Eclipse Foundation. “Eclipse Kanto delivers a powerful open source solution that meets this need and, in fact, provides more robust functionality than existing solutions.”  Eclipse Kanto is optimized for complex IoT edge devices facing limited hardware resources, (near) real-time requirements, diverse device software, heterogeneous data sources and the ability to operate without connection. The project can run various automotive and industrial hardware like vehicle computers, connected building gateways, industrial controllers and more. Eclipse Kanto is based on lightweight native components, open protocols and standard containers that ensure availability on hardware, minimum integration work, reduced complexity, rapid prototyping, and scalable applications.  The Eclipse Kanto software stack is implemented in Go to naturally integrate with existing cloud native technologies, frameworks and ecosystems, meet footprint and (near) real-time constraints, leverage modern development toolchains and ensure optimal learning curve for IoT and open source developers. As Eclipse Kanto is modular by nature, new components can also be implemented in other languages like Rust, C/C++ depending on the use cases and problems they solve. This makes it a suitable technology for emerging paradigms such as software-defined vehicles, connected machines and connected manufacturing, smart appliances, smart buildings and many more! Eclipse Kanto was built incorporating Bosch.IO’s and Eclipse IoT Working Group knowledge and expertise spanning 20+ years of experience in the field of edge computing and IoT. Eclipse IoT is home to open source innovation that has delivered some of the industry’s most popular IoT protocols. CoAP (Eclipse Californium), DDS (Eclipse Cyclone DDS), LwM2M (Eclipse Leshan), MQTT (Eclipse Paho, Eclipse Mosquitto and Eclipse Amlen) and OPC UA (Eclipse Milo) are all built around Eclipse IoT projects. Other popular Eclipse IoT production-ready platforms cover use cases such as cloud connectivity (Eclipse Hono), digital twins (Eclipse Ditto), software updates (Eclipse hawkBit), energy management (Eclipse VOLTTRON), contactless payments (Eclipse Keyple), smart cities (Eclipse Kura) in addition to Eclipse Kapua — a modular IoT cloud platform. To learn more about how to get involved with Eclipse IoT, Edge Native, Sparkplug or other working groups at the Eclipse Foundation, visit the Foundation’s membership page. Working group members benefit from a broad range of services, including exclusive access to detailed industry research findings, marketing assistance, and expert open source governance. For further IoT & edge related information, please reach us at: [email protected] [email protected] Quotes from Members Bosch.IO “We believe that open source is where true collaboration, co-development, and co-innovation can happen. Eclipse IoT is already a happy home for mature IoT projects like Eclipse Hono, Eclipse Ditto and Eclipse hawkBit” said Dr. Olaf Weinmann, Head of Device and Data Management at Bosch.IO. “We are bringing the devices and their applications together with the backend stack. Eclipse Kanto will enable synergies between existing embedded and cloud ecosystems to converge knowledge and technology. It adopts key concepts like cloud connectivity via Eclipse Hono, managing and controlling edge devices and their features by using Eclipse Ditto and many more. By bringing Eclipse Kanto in Eclipse IoT we provide a standard integration between devices and cloud to further enrich and extend the existing ecosystem.” Bosch “Considering the vision of a unified control plane for orchestrating software workloads on software-defined vehicles (SDV), the Kanto project can be a key building block for integrating cloud and edge” said Daniel Krippner, Enterprise Architect and Tech Strategist of software-defined vehicles at Bosch. "As SDV-focused open source working groups are forming and beginning to define their position in the industry, cornerstones like Eclipse Kanto and other open source projects will be invaluable anchors for broadening relevant open source-driven engagements in this space." Collabora “Following in the footsteps of well-established Eclipse IoT projects like Eclipse hawkBit™, Eclipse Kanto will help in simplifying IoT edge software and associated data,” said Guy Lunardi, Vice President of Business Development at Collabora. “Collabora is firmly convinced that flexible software updates have been overlooked for too long and are now a critical component for any product moving forward, for the automotive industry and beyond.”   About the Eclipse Foundation The Eclipse Foundation provides our global community of individuals and organizations with a mature, scalable, and business-friendly environment for open source software collaboration and innovation. The Foundation is home to the Eclipse IDE, Jakarta EE, and over 400 open source projects, including runtimes, tools, and frameworks for cloud and edge applications, IoT, AI, automotive, systems engineering, distributed ledger technologies, open processor designs, and many others. The Eclipse Foundation is an international non-profit association supported by over 330 members, including industry leaders who value open source as a key enabler for their business strategies. To learn more, follow us on Twitter @EclipseFdn, LinkedIn or visit eclipse.org. Third-party trademarks mentioned are the property of their respective owners. ### Media contacts: Schwartz Public Relations for the Eclipse Foundation, AISBL Julia Rauch / Sophie Dechansreiter / Tobias Weiß Sendlinger Straße 42A 80331 Munich   [email protected] +49 (89) 211 871 – 43 / -35 / -70 Nichols Communications for the Eclipse Foundation, AISBL Jay Nichols [email protected] +1 408-772-1551 [Less]

Are you developing a custom tool with Eclipse Theia and are in need of a comprehensive test strategy? A test strategy... The post Theia Playwright – End-to-end testing Theia applications appeared first on EclipseSource.