<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[codewind - Medium]]></title>
        <description><![CDATA[Container development unleashed Codewind simplifies and enhances development in containers by extending industry standard IDEs with features to write, debug, and deploy cloud-native applications. - Medium]]></description>
        <link>https://medium.com/codewind?source=rss----8b4ff73e9142---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>codewind - Medium</title>
            <link>https://medium.com/codewind?source=rss----8b4ff73e9142---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 10:06:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/codewind" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Creating a “hello, world” Open Liberty project in Eclipse Codewind: a user journey]]></title>
            <link>https://medium.com/codewind/creating-a-hello-world-open-liberty-project-in-eclipse-codewind-a-user-journey-6dc4b35c05b1?source=rss----8b4ff73e9142---4</link>
            <guid isPermaLink="false">https://medium.com/p/6dc4b35c05b1</guid>
            <category><![CDATA[ide-tools]]></category>
            <category><![CDATA[eclipse]]></category>
            <category><![CDATA[codewind]]></category>
            <category><![CDATA[vscod]]></category>
            <category><![CDATA[open-liberty]]></category>
            <dc:creator><![CDATA[Becca Bau]]></dc:creator>
            <pubDate>Thu, 23 Apr 2020 22:19:57 GMT</pubDate>
            <atom:updated>2020-04-24T01:10:28.155Z</atom:updated>
            <content:encoded><![CDATA[<p>I started my day off staring at a blank <a href="http://codewind.dev/">Eclipse Codewind</a> Open Liberty template. If you are not familiar with Codewind, it’s a free, open source IDE extension currently available in VS Code, Eclipse, and IntelliJ (and you can use it in other configurations besides the local configuration explored in this blog, but you can read about that <a href="https://developer.ibm.com/technologies/containers/blogs/codewind-introduction/">here</a>). My goal today was to create a “hello, world” type application, but I had never used Open Liberty before, and had no idea where to start.</p><p>Open Liberty is an open source server runtime for Java developers that claims to bring more efficiency to building cloud-native apps and microservices, since you only run what you need (which is neat!). Because I wanted a little more understanding of the framework, I started with a <a href="https://openliberty.io/downloads/#maven">guide</a> and ended up spending about 30 minutes troubleshooting my maven configuration (or lack thereof) on my Mac. With the help of my trusty friend Google, I found that I could just install maven via Homebrew, so I ran:</p><pre>brew install maven</pre><p>And then I hit my second problem:</p><pre>beccabau@beccabaus-mbp ~ % mvn -v<br>The JAVA_HOME environment variable is not defined correctly<br>This environment variable is needed to run this program<br>NB: JAVA_HOME should point to a JDK not a JRE</pre><pre>beccabau@beccabaus-mbp ~ % echo $JAVA_HOME<br>/Library/Java/Home</pre><pre>beccabau@beccabaus-mbp ~ % $JAVA_HOME/bin/javac -version<br>zsh: no such file or directory: /Library/Java/Home/bin/javac</pre><p>Okay, so clearly I needed to figure out how to get my <a href="https://www.baeldung.com/maven-java-home-jdk-jre">path to point to my JDK</a>.</p><p>On my Mac, I needed to edit:</p><pre>~/.bash_profile</pre><p>by adding the following line:</p><pre>export JAVA_HOME=$(/usr/libexec/java_home)</pre><p>Then I sourced it,</p><pre>source ~/.bash_profile</pre><p>(see full description and other OS instructions <a href="https://www.baeldung.com/java-home-on-windows-7-8-10-mac-os-x-linux">here</a>).</p><p>Tested and double-checked it was working:</p><pre>beccabau@beccabaus-mbp ~ % echo $JAVA_HOME<br>/Library/Java/JavaVirtualMachines/jdk-12.0.2.jdk/Contents/Home<br>beccabau@beccabaus-mbp ~ % mvn -v<br>Apache Maven 3.6.3 (cecedd343002696d0abb50b32b541b8a6ba2883f)<br>Maven home: /usr/local/Cellar/maven/3.6.3_1/libexec<br>Java version: 12.0.2, vendor: Oracle Corporation, runtime: /Library/Java/JavaVirtualMachines/jdk-12.0.2.jdk/Contents/Home<br>Default locale: en_US, platform encoding: UTF-8<br>OS name: “mac os x”, version: “10.15.3”, arch: “x86_64”, family: “mac”</pre><p>Success! Continued on with the tutorial…</p><p>So I cloned the project and deployed the app. Then what? Well, next section showed that I could pull the Open Liberty images with Docker, so maybe I didn’t actually need to get and configure maven? <a href="https://emojipedia.org/weary-cat/">🙀</a></p><p>Stoically, I moved on. I used the docker command and pulled the latest images.</p><pre>docker pull open — liberty</pre><p>The images were pulled pretty quickly, and I followed the <a href="https://openliberty.io/guides/containerize.html">link</a> to continue, which led me to containerizing a microservice and another guide! It contained maven commands, so it looked like I was on the right track. <a href="https://emojipedia.org/grinning-face-with-sweat/">😅</a></p><p>While the guides were educational and easily followed, they weren’t what I really wanted. They helped me containerize my app and get my server started, but Codewind does all that for me.</p><p>So after some more googling, I found a <a href="https://www.youtube.com/watch?v=PnHT4ld0w18">video</a> that walked me through how Open Liberty files were organized, and which file to edit to make a simple app. It mostly worked out of the box, but I did have to add a few things here and there to make it work. Once I figured out what I was doing, it only took about 5–10 minutes to get the app working, as opposed to the few hours spent pouring through the guides to find myself back to where I started.</p><p>Now I have a working app, and I can make it say “hi” to me :).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/712/1*hHPyeuqg4t1bsLeubtXP6A.gif" /></figure><p>If you want to see how easy it is to get started with a blank Open Liberty template, try it out in this <a href="https://github.com/beccabau/codewind-vscode-openliberty-walkthrough">quicklab</a> I wrote!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6dc4b35c05b1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codewind/creating-a-hello-world-open-liberty-project-in-eclipse-codewind-a-user-journey-6dc4b35c05b1">Creating a “hello, world” Open Liberty project in Eclipse Codewind: a user journey</a> was originally published in <a href="https://medium.com/codewind">codewind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Testing my applications on the next Node.js version (right now, it’s v14)]]></title>
            <link>https://medium.com/codewind/testing-my-applications-on-the-next-node-js-version-right-now-its-v14-3fb853f87e2a?source=rss----8b4ff73e9142---4</link>
            <guid isPermaLink="false">https://medium.com/p/3fb853f87e2a</guid>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Nik Canvin]]></dc:creator>
            <pubDate>Tue, 21 Apr 2020 08:08:54 GMT</pubDate>
            <atom:updated>2020-04-21T07:41:12.098Z</atom:updated>
            <content:encoded><![CDATA[<p>As another new Node.js LTS version comes out (v14 this time), I wanted to test my Node.js investments against it, ultimately aiming to upgrade them as efficiently and effectively as possible. Using <a href="http://ibm.biz/20200417-blog-codewind">Codewind</a> (an open source plugin for your IDE) I swapped the Node.js versions over and tested them, here’s how easy it was.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v4TLE4n8PfwB8u1kLj10UQ.png" /><figcaption>instant application ‘response time‘ results when repeatedly under load, demonstrated v14 would run and performance had not regressed</figcaption></figure><p>Well, it was easy after I jumped the ‘updating my Node.js version to a pre-release nightly build’ hurdle, which I’ll explain at the bottom for anyone interested in doing the same.</p><p>I have many Node.js applications and microservices in production, covering release time legals process automation and more recently gathering, analysing and report various business metrics. Continuously keeping them on the latest software stack protects them from accruing deprecated API technical debt.</p><p>Thankfully due to all the benfits of ‘twelve-factor apps’[1], I previously choose to run all my Node.js workloads as cloud-native microservices. This meant all the dependencies (including software stack layers) were already ‘explicitly declared and isolated’. You can read how I easy I found doing this in: ‘My first cloud-native Node.js microservice, from nothing to running, immediately’[2].</p><p>Rebuilding and testing my applications on Node.js v14 was as simple as a small change in the Dockerfile, which was made easier still using Codewind as it automatically spotted the file change, rebuild, restarted the containerized application and provided five great time saving tools for me to have a poke about and have confidence in the Node.js version change.</p><h3>Top 5 time saving Codewind features, that helped with this ‘upgrade stack test’ scenario</h3><h4>1. Performance testing, fully integrated in Codewind</h4><p>Checking your continuous code updates for any unintended performance regressions is a powerful capability provided ‘out-the-box’ in Codewind. The sooner you spot any issues, especially complex performance ones, the better.</p><p>In this scenario, the only code change was the Node.js version declaration and I was able to instantly check the performance between Node.js v14 and v12.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/404/1*36QuDf2n4yUfXq1n3_cGDA.png" /><figcaption>click:</figcaption></figure><p>A simple configuration panel enabled me to inflict the workload challenge for my application. I wanted to test just enough load to have confidence in the Node version upgrade but without causing any ‘rate-limiting’ algorithm to kick in on a live web page my application was hitting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1014/1*OHoLSOHObfDcorm9kje-Qw.png" /><figcaption>configure testing runs, I hit the ‘get-data’ endpoint with several parameters, 30 times a second (10 at a time), for 20 seconds … I was sensitive not to hammer harder, as the microservice was hit a live web page elsewhere</figcaption></figure><p>Results in, everthing was clean:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J43ORMtayTl3SF7GpVE3Lw.png" /><figcaption>graphed results of 10 runs, 5 with Node v14, then 5 more with Node v12.. response time looked pretty consistent to me (only outlier was the middle v12 (the 8th) run, probably an insignificant network blip)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yAaOsricER2xd_9DooALjA.png" /><figcaption>results also tabularised, where any individual runs can be selected/deleted from the data if desirable (such as removing the noisy 8th run)</figcaption></figure><h4>2. Application health metrics constantly collected and displayed</h4><p>During playtime with the application above, I was able to watch the http response time, as well as impact on CPU and memory use, to look for any irregularities.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/388/1*19t5fuuq5tEz6ggY-Z-WQw.png" /><figcaption>click:</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*srIDBIiYlVjHUdvtk0GlvA.png" /><figcaption>snap-shot was taken after the first 5 performance runs, from the next cool feature below:</figcaption></figure><h4>3. Quick launch application for a manual sniff test</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/346/1*koVbLpGqCBdiWMs5LZp9QA.png" /><figcaption>click:</figcaption></figure><p>The microservice served a web page, providing links that enable me to quickly test it with many different parameters:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/768/1*4yYTYXZL1kkbBlfmv557qg.png" /><figcaption>clicking a link ran the microservice, which got some business metrics and returned JSON</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OsGidaujkvTzYHdTQ_801Q.png" /><figcaption>application results, demonstraing ‘business as usual’ on new Node.js version</figcaption></figure><h4>4. Simple ‘click to open a shell’ inside the running container.</h4><p>OK, it’s easy to ‘docker run …’ if you know how, but you need to remember the command and some lightweight docker images I use don’t have ‘bash’ so starting a container and keeping it running long enough can be a pain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/442/1*FjIkV5QGBommkTswhbE7Ww.png" /><figcaption>click:</figcaption></figure><p>I used this to double check the run container running the application actually had Node.js v14 running in it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/703/1*f3LueHE0oI1roA0IQDXhNg.png" /><figcaption>able to quickly check ‘node -v’ running in the actual container, v14 nightly build was present</figcaption></figure><h4>5. Keep an eye on the build logs tick past</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/366/1*fbVtjgyca9k7scjvdPqBGA.png" /><figcaption>click:</figcaption></figure><p>First the Docker build then the Application build log, helped me debug my issue when ‘updating the Node.js version to pre-release nightly build’, which I cover at the bottom of this blog</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/701/1*EqV38FWvormcQ8fMqoBOSA.png" /><figcaption>Docker build log firing up….</figcaption></figure><h3>In Summary</h3><p>The combination of modernising business workloads using ‘twelve factor’[1] application implementations with <a href="http://ibm.biz/20200417-blog-codewind">Codewind</a> for rapid iterative development of cloud-native applications, enabled me to simply and quickly maintain software stack currency.</p><p><strong><em>and finally, as promised above: Updating my Node.js version to a pre-release nightly build’</em></strong></p><p>I hoped it would be as simple as changing the Dockerfile ‘from’ declaration from ‘node:12-stretch’ to ‘node:14-stretch’, causing the software stack to base off Node.js v14 as the first step of the build process. However, as v14 was not released until the following week, there were no Node.js v14 images on Dockerhub ready for use.</p><p>Instead I retained the ‘node:12-stretch’ declaration and opted to download/update the Node.js version during the Docker build process. I added a couple of ‘node -version’ queries too, before and after the upgrade to check the results.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/988/1*yu0wglmdGAhnR5gIaumlpA.png" /><figcaption>Dockerfile updates made (pre-release node v14 nightly builds shown) .. for example only as I commented them out, I’ve also shown what post-release node builds would look like for v13</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/703/1*NeUIp1hR2dBgkRJutU5JKQ.png" /><figcaption>docker.build.log (shows node version used before and after update)</figcaption></figure><h4>Reference links:</h4><ul><li><a href="http://ibm.biz/20200417-blog-codewind">Codewind landing page</a> (for news, blogs, github repos, twitter, etc)</li><li>[1] <a href="https://12factor.net/dependencies">twelve-factor apps/dependencies</a></li><li>[2] <a href="https://medium.com/codewind/my-first-cloud-native-node-js-microservice-from-nothing-to-running-immediately-13a49be74ba8">My first cloud-native Node.js microservice, from nothing to running, immediately</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3fb853f87e2a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codewind/testing-my-applications-on-the-next-node-js-version-right-now-its-v14-3fb853f87e2a">Testing my applications on the next Node.js version (right now, it’s v14)</a> was originally published in <a href="https://medium.com/codewind">codewind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[JDK 14 is coming, but will my Java application run on it?]]></title>
            <link>https://medium.com/codewind/jdk-14-is-coming-but-will-my-java-application-run-on-it-49bac9ee145b?source=rss----8b4ff73e9142---4</link>
            <guid isPermaLink="false">https://medium.com/p/49bac9ee145b</guid>
            <category><![CDATA[jdk]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[containers]]></category>
            <dc:creator><![CDATA[Nik Canvin]]></dc:creator>
            <pubDate>Wed, 18 Mar 2020 10:41:12 GMT</pubDate>
            <atom:updated>2020-03-19T08:00:46.299Z</atom:updated>
            <content:encoded><![CDATA[<h3>JDK 14 is now here, but will my Java application run on it?</h3><p>well, … NO… as it turns out… for my specific application at least, here’s how I tested against JDK14, then found, debugged and fixed an issue in minutes!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*oRhLFDLPEuhZL8lBHipCZQ.gif" /><figcaption>JDK 14 tested clean, after an issue was identified/fixed</figcaption></figure><p>New versions of the layers in your application software stack are continuously released and often contain API breaking changes, especially as security fixes strive to lock down every possible risky code path. In the latest JDK14 release[1] for example, the ‘JEP367 to Remove the Pack200 Tools and API’[2] could bring your application or build process to a grinding halt and if it does, what can you do about it!</p><p>Staying current on the latest software stack has never been more critical to ensure your application gets the latest security features and fixes, as well as minimizing business agile development blocking technical debt!</p><p>The best way to stay current is to continuously test your application on latest stack levels, so here I’ve shared a great quick, easy and cheap way to achieve it. However, before I share my favourite method, it’s worth pointing out support can mean two things, which I’ll touch on later on:</p><ol><li>Toleration — simply put, will the application still run at all!</li><li>Exploitation- will the application run better in some way, such as faster due to performance improvements, more resilient due to enhanced fault toleration, or maybe easier to debug issues thanks to new diagnostic features.</li></ol><h3>Containerize your application and simply interchange software stack levels as required</h3><p>Running a Java application in a container, using an implementation such as OCI or Docker, enables it to easily run in a controlled environment. Then in this JDK 14 case, I simply switched the Java Runtime used, re-built the container and tested it.</p><p>Simple in theory but the investment and maintenance of containerization skills and devops pipelines pain point, adds yet more pressure on stretched technology teams. This is where <a href="http://ibm.biz/20200312-codewind">Eclipse Codewind</a> had the answer, as it’s designed specifically to automate this pain point. Developing in your favorite IDE (Intellij, Eclipse and VS Code all currently supported), Codewind handles the Containerization and Kubernetes part automatically. To switch the JDK version to 14 (I was previously running on JDK8), I saved a simple update to the Dockerfile and Codewind did the rest.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*8RGuiLyScP9RlmwiEp2eXQ.png" /><figcaption>Switched the build process to JDK14, in the Dockerfile</figcaption></figure><p>The update was automatically spotted and new container instantly built and …oh, a BUILD FAILURE .. not what I was expecting. A ‘maven-war-plugin’ hit an API incompatibility issue:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/707/1*GrPFMxeMVmxix3_v8zEDcg.png" /><figcaption>Docker build log extract, (using Codewind plugin in VS Code)</figcaption></figure><p>Toggling back to JDK13 the application built and ran, providing instant confirmation that this breaking change was introduced in JDK14.</p><p>Using Codewind to search the project for ‘maven-war-plugin’ I found it declared in the ‘pom.xml’ file, using version ‘2.6’. A quick web search steered me to the MvnRepository page, where I saw ‘2.6’ was released in 2015 (might security vulnerabilities lurk in that) and the latest version is now ‘3.2.3&#39;, so a quick edit to the pom.xml was made:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/456/1*4kLZ3kB6WdfaDMxX8-aAfA.png" /><figcaption>Bumping the version from 2.6 up to the latest 3.2.3 ( update made/saved in Codewind)</figcaption></figure><p>Codewind automatically spotted the ‘pom.xml’ file save, rebuilt the application (fully successful that time) and ran it. Issue resolved!</p><h3>Just to recap</h3><p>A build process pre-requisite did not support JDK14. However, without personally having installed Kubernetes or having containerization skills, using Codewind I was able use containerization to test, find and fix an issue, in a matter of minutes.</p><h4>Here are a few extra tips to consider:</h4><ol><li>Regarding testing for ‘exploitation’ mentioned above, Codewind has built-in performance monitoring and testing tools, that enable measurement of any improvements achieved by switching software stack layers.</li><li>It may be worth fully automation the currency testing activity. You could automate systematic changes to the Dockerfile, changing each software stack layer to the latest versions/releases and running your test suite against it. This could provide you with the earliest possible feedback that some technical debt had been incurred, helping you to plan to most cost effective response.</li><li>Of course the larger the application, the more APIs that are used in pre-requisite software, the more likely it is that stack currency testing hit issues. Here’s a great approach breaking application down into bite size microservices, see Modernize existing apps and build new cloud-native apps[4], offered by IBM.</li><li>Here’s one final tip regarding consolidating management and patching of software levels in the application stack of multiple microservices in one go (for example, bumping up the JDK level of many microserivces). Using the architectural stack features in Kabanero.io[5], a single JDK level change can instantly feed into scoped future development and deployment of new or updated microservices.</li></ol><p><strong><em>References mentioned above:</em></strong></p><ol><li><em>JDK 14 release contents: </em><a href="https://openjdk.java.net/projects/jdk/14/"><em>https://openjdk.java.net/projects/jdk/14/</em></a></li><li><em>JEP367 to Remove the Pack200 Tools and API: </em><a href="https://openjdk.java.net/jeps/367"><em>https://openjdk.java.net/jeps/367</em></a></li><li><em>Eclipse Codewind (plug-in for VS Code, Eclipse and Intellij) to automate application containerization develop/build/run iterations: </em><a href="https://www.eclipse.org/codewind/"><em>https://www.eclipse.org/codewind/</em></a></li><li><em>Modernize existing apps and build new cloud-native apps, offered by IBM: </em><a href="https://www.ibm.com/cloud/cloud-pak-for-applications"><em>https://www.ibm.com/cloud/cloud-pak-for-applications</em></a></li><li><em>Kabanero, an open source project focused on bringing together foundational open source technologies into a modern microservices-based framework: </em><a href="https://kabanero.io/"><em>https://kabanero.io/</em></a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=49bac9ee145b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codewind/jdk-14-is-coming-but-will-my-java-application-run-on-it-49bac9ee145b">JDK 14 is coming, but will my Java application run on it?</a> was originally published in <a href="https://medium.com/codewind">codewind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My first cloud-native Node.js microservice, from nothing to running, immediately]]></title>
            <link>https://medium.com/codewind/my-first-cloud-native-node-js-microservice-from-nothing-to-running-immediately-13a49be74ba8?source=rss----8b4ff73e9142---4</link>
            <guid isPermaLink="false">https://medium.com/p/13a49be74ba8</guid>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Nik Canvin]]></dc:creator>
            <pubDate>Wed, 18 Mar 2020 10:31:56 GMT</pubDate>
            <atom:updated>2019-11-02T15:15:37.361Z</atom:updated>
            <content:encoded><![CDATA[<p>Having read about the virtues of <a href="https://www.12factor.net/">12-factor App</a>s, I knew I wanted to develop a new microservice — something that would handle one task really well and be easy to deploy to any cloud, but did not have the Kubernetes and Docker skills required. However, using <a href="http://ibm.biz/eclipse-cw01">Eclipse Codewind</a>, a developer experience designed specifically to make cloud-native development simple, I was up and running immediately.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DRd_7YlKH-4U0gtbnuhtew.jpeg" /><figcaption>From VS Code, I clicked to create/run a new microservice. A few dev iterations later to add my application logic, and I was DONE.</figcaption></figure><p>Having worked as a Software Project Manager for 20 years, I’m currently focused on legally dispositioning all the open source packages that my offering uses and tasked with producing software licenses and copyright notices files. Since the explosion of technologies like Node.js, Go-lang and Docker, the number of Open Source package sub-dependencies can quickly spiral into the 100s in my case.</p><p>I’m not alone. Across my company many other offerings are in the same boat, and the response has been consistently frustrating. Localized automation tightly coupled to local environments and needs, has stifled reuse. That is what inspired me to use the modern microservices approach, providing common jigsaw pieces of function, aiming to transform the local-only automation anti-pattern.</p><p>Getting started developing a microservice was remarkably simple, as the Codewind experience seamlessly did all the containerization heavy lifting. After the one click installation and setup of <a href="https://docs.docker.com/docker-for-mac/install/">Docker on my Mac</a>, I installed the <a href="http://ibm.biz/vsc-ecw">Codewind extension in VS Code</a> (other IDEs are also supported) and I was all set.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wd4zSs4apKYOKKg4_A9YMQ.png" /></figure><p><strong>To IMMEDIATELY get a running cloud-native microservice:</strong></p><ol><li><a href="http://ibm.biz/ecw-getstarted">Install Codewind</a> (I picked the VS Code extension).</li><li>In Codewind click ‘create project’.</li><li>Pick a type. In my case I used ‘Express Node.js’, but many other stacks/languages supported.</li><li>Give it a name, then &lt;enter&gt;.</li></ol><p><strong>DONE.</strong></p><p>What I got was a fully formed dockerized Node.js ‘hello-world’ microservice that I could see in my browser, the source to play with in VS Code, shell access to the running container, an application health metrics monitor and a performance testing capability.</p><p>The ‘Inner Loop’ feature, instantly rebuild/ran any code changes I made, providing instant feedback as I developed. Some types of changes required rebuilding/starting the Docker container the app runs in, but that was transparent to me, as Codewind had the smarts to handle everything in the background.</p><p>My first microservice was a utility to re-format copyright CSV data into the notices legal file format required for my offering. Since then, I’ve written several more microservices, continuing to automate parts of the end-to-end open source usage legal process.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FhFZYn8vK-gg%3Ffeature%3Doembed&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DhFZYn8vK-gg&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FhFZYn8vK-gg%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/b0bb62b7ba9bd737b4e648b48e71a6dd/href">https://medium.com/media/b0bb62b7ba9bd737b4e648b48e71a6dd/href</a></iframe><p>Developing microservices with <a href="http://ibm.biz/eclipse-cw01">Eclipse Codewind</a> has been extremely productive, as I’ve spent zero time worrying about setting up and driving a cloud-native development environment. Neither has any time been wasted figuring out how to containerize my app, then manually drive development build/run/test iterations. Instead, I’ve been able to devote 100% of my time on the business logic in my chosen language.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=13a49be74ba8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codewind/my-first-cloud-native-node-js-microservice-from-nothing-to-running-immediately-13a49be74ba8">My first cloud-native Node.js microservice, from nothing to running, immediately</a> was originally published in <a href="https://medium.com/codewind">codewind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducing Eclipse Codewind on IntelliJ]]></title>
            <link>https://medium.com/codewind/introducing-eclipse-codewind-on-intellij-aa3f5d1adff5?source=rss----8b4ff73e9142---4</link>
            <guid isPermaLink="false">https://medium.com/p/aa3f5d1adff5</guid>
            <category><![CDATA[intellij]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[codewind]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[ide]]></category>
            <dc:creator><![CDATA[Becca Bau]]></dc:creator>
            <pubDate>Thu, 05 Mar 2020 15:38:16 GMT</pubDate>
            <atom:updated>2020-03-10T20:00:08.107Z</atom:updated>
            <content:encoded><![CDATA[<p>We recently announced the tech preview of Eclipse Codewind on the <a href="https://www.jetbrains.com/idea/">IntelliJ IDE</a>. Many people have asked about IntelliJ, as it is a popular option among Java developers, and we want to make our tools available to as many developers as possible in their preferred IDEs. With this tech preview, you can now use Codewind on IntelliJ locally, and we are working hard to bring the full, effortless Codewind experience to IntelliJ over the coming months.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ylJNZ372UDizqDM1is3X4g.gif" /><figcaption>Creating a MicroProfile project using the IntelliJ IDE</figcaption></figure><p>Get started with Codewind on IntelliJ <a href="https://www.eclipse.org/codewind/mdt-intellij-getting-started.html">here</a>!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*en0TEMpUTWMELlVWz7brDA.png" /><figcaption>Get the Codewind plugin in the IntelliJ IDE Marketplace!</figcaption></figure><h4><strong>Refresh my memory, what is Eclipse Codewind again?</strong></h4><p>Eclipse Codewind is an open source project for building and developing cloud-native, containerized applications. Built from the ground up, Codewind provides an improved and integrated IDE-based container development flow. Codewind does all the hard stuff, from creating your project to optimization so you can focus on rapidly iterating your code. Plus, you can debug your remote applications as if they were on your local machine. You can see all the metrics and logs you need, and perform load testing with a click of a button. Relax into the familiar flow of traditional application development without needing to be an expert in container technology.</p><h4>Why do we care about Codewind?</h4><p>Container development is a regularly utilized process for developing for cloud-native applications, but debugging the deployment process can be tricky. Let’s discuss the different ways Codewind can help you out.</p><p>Codewind provides preconfigured, Docker-containerized <a href="https://www.eclipse.org/codewind/workingwithtemplates.html">project templates</a> covering multiple popular languages and frameworks that you’re already familiar with. You can modify the preconfigured projects to develop your customized microservices. As you develop, Codewind automatically pushes your code changes to your container as efficiently as possible.</p><p>Codewind offers a smooth debugging and testing experience inside your IDE. Run commands and access your application, build, and container logs from within the container. Use the Project Overview interface to view the endpoint, container ID, location on disk, build/run status, and ports, so you don’t have to leave your IDE to search for this information. Codewind integrates with your IDE’s terminal window and Problems and Output panels for a smooth test and debug experience. Additionally, you can open a shell session inside your container with a simple click. And best of all, you get to do all this with full compatibility with the debug functionality of your IDE.</p><p>You can also visualize your container application’s footprint, such as CPU and memory usage (where supported). Codewind’s Application Metrics Dashboard exposes your microservice’s core metrics, including HTTP(S) requests and throughput information, as well as CPU usage, memory footprint, and heap. Codewind also features integrated load-testing for certain project types.</p><p>Codewind also features integrated load-testing for certain project types. You can configure and run load tests against your microservices using <a href="https://www.youtube.com/watch?v=nfJt3f5TUvc">Codewind’s performance dashboard</a>, and use the graphs to compare your repeated load test results and iterate on performance improvements.</p><p>As an open-source project, we cater to our users, so if you’ve got any suggestions or want to get involved, let us know! We are on <a href="https://github.com/eclipse/codewind">GitHub</a> and <a href="https://mattermost.eclipse.org/eclipse/channels/eclipse-codewind">Mattermost</a> and happy to chat.</p><h4>Where can I use Codewind?</h4><p>Full functionality on <a href="https://www.eclipse.org/codewind/mdt-vsc-getting-started.html">VS Code</a>, <a href="https://www.eclipse.org/codewind/mdt-eclipse-getting-started.html">Eclipse IDE</a>, <a href="https://www.eclipse.org/codewind/mdt-che-installinfo.html">Eclipse Che</a>, and partial functionality in <a href="https://www.eclipse.org/codewind/mdt-intellij-getting-started.html">IntelliJ</a> with plans to expand — which is great news for Java developers!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aa3f5d1adff5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codewind/introducing-eclipse-codewind-on-intellij-aa3f5d1adff5">Introducing Eclipse Codewind on IntelliJ</a> was originally published in <a href="https://medium.com/codewind">codewind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sneak Peek: Remote Development with Codewind]]></title>
            <link>https://medium.com/codewind/sneak-peek-remote-development-with-codewind-79a0ec5ed37c?source=rss----8b4ff73e9142---4</link>
            <guid isPermaLink="false">https://medium.com/p/79a0ec5ed37c</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[remote-development]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[codewind]]></category>
            <category><![CDATA[eclipse]]></category>
            <dc:creator><![CDATA[Becca Bau]]></dc:creator>
            <pubDate>Thu, 19 Dec 2019 15:11:20 GMT</pubDate>
            <atom:updated>2019-12-20T20:31:21.666Z</atom:updated>
            <content:encoded><![CDATA[<p>(Brought to you by Julie Stalley, John Collier, and Becca Bau)</p><p>In our Codewind <a href="https://www.eclipse.org/codewind/news07.html">0.7.0 release</a>, we’re very excited to share with you a preview of our latest feature: a remote development scenario with Codewind! We can hear you asking, “Why should I even care?”</p><p>Well, first, let me start by telling you what it even is. Our remote scenario enables you to develop locally on Codewind — meaning you get to use your own IDE! — and then securely build and run your service on a remote instance of Codewind in the cloud. This is really great news for Kubernetes developers everywhere.</p><p>Now, why is this so cool?</p><p>1. You get to take control of your Kubernetes development. You can use your favorite IDE — on your laptop or local machine — and build and run code straight in the cloud on Kubernetes.</p><ul><li>This means you don’t have to change IDEs if you want to start developing in the cloud, so you still have access to your favorite plugins and language server packs. Why would you give them up if you don’t have to?</li><li>You can dedicate your local machine to focus purely on developing code and use the cloud’s resources to build and run your apps.</li></ul><p>2. It abstracts away a lot of the complicated parts of app development on Kube. This also applies for Che.</p><ul><li>You no longer need to worry about figuring out how to push your images up to a registry, where to build and run your apps, and figuring out how to update or debug that application.</li><li>That translates to more time spent developing!</li></ul><p>3. You can develop against multiple clouds at once (relevant when you want to compare clouds quickly, among other reasons).</p><ul><li>With our remote scenario, you can install Codewind on multiple clouds, but have a single IDE pointing to all your Codewind instances. For example, you can have 3 projects in your IDE workspace instead of needing 3 separate editors for all of your builds on 3 separate instances of Codewind.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iuzzT8hskeF_qL-C739QXA.jpeg" /><figcaption>You can have all your projects in one editor and still deploy to multiple clouds.</figcaption></figure><p>TL;DR:</p><ul><li>Codewind now supports connecting your local IDE of choice to Codewind installed in a remote cloud.</li><li>Connect to multiple clouds as well as your local installation of Codewind.</li><li>Keep your favorite IDE and all your favorite tools and easily run your microservice in Kubernetes.</li></ul><p>Questions or feedback?</p><ul><li>Visit <a href="https://codewind.dev/">codewind.dev</a>.</li><li>Connect with us on <a href="https://mattermost.eclipse.org/eclipse/channels/eclipse-codewind">Mattermost</a>.</li><li>Open a <a href="https://github.com/eclipse/codewind/issues/new/choose">feature request or issue</a>.</li><li>Start <a href="https://github.com/eclipse/codewind">contributing</a> with us!</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=79a0ec5ed37c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codewind/sneak-peek-remote-development-with-codewind-79a0ec5ed37c">Sneak Peek: Remote Development with Codewind</a> was originally published in <a href="https://medium.com/codewind">codewind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Want to get a microservice up and running super quickly? Try Codewind.]]></title>
            <link>https://medium.com/codewind/want-to-get-a-microservice-up-and-running-super-quickly-try-codewind-5bf7c35f0c80?source=rss----8b4ff73e9142---4</link>
            <guid isPermaLink="false">https://medium.com/p/5bf7c35f0c80</guid>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[vscode]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[development]]></category>
            <dc:creator><![CDATA[Dr Melanie Hopper]]></dc:creator>
            <pubDate>Tue, 10 Dec 2019 13:43:48 GMT</pubDate>
            <atom:updated>2019-12-10T14:57:02.690Z</atom:updated>
            <content:encoded><![CDATA[<p>Whether you are new to the world of microservices, or are a seasoned containerised applications developer, you’ll know of the various ways that your time can be sapped from the nitty gritty work of writing good code.</p><p>There’s the task of <strong>creating your own application stack for a containerised microservice </strong>that also fits your preferred language and project type.</p><p>Then there’s the <strong>multiple commands you must run </strong>to build images, create containers, assess build status, open end points, debug, eyeball the different logs, assess performance metrics, re-build the containers with each code change…the list goes on.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/444/1*Fe4S-Qq4pLbRvpsCkQVI0A.jpeg" /></figure><p><strong>Well, there’s an open source tool that’s been developed with you in mind. It’s called </strong><a href="http://codewind.dev/"><strong>Codewind</strong></a><strong>.</strong></p><blockquote>Not only will you be able to choose your microservice from a list of pre-supplied project templates, you’ll have a fully integrated container development environment at your fingertips.</blockquote><p>Say what?</p><p>We’ll show you.</p><p>We’re going to get a microservice up and running in a container within 2 minutes just by using the <a href="http://codewind.dev/">Codewind</a> plugin for VS Code. Then we’re going to run through some of the features that Codewind provides for your inner loop work.</p><p>Let’s get started.</p><h4><strong>1. Choose your microservice from Codewind’s list of pre-configured, container-ready project templates</strong></h4><p>After getting our pre-requisites of <a href="https://www.docker.com/products/docker-desktop">Docker Desktop</a> and <a href="https://marketplace.visualstudio.com/items?itemName=IBM.codewind">Codewind for VS Code</a> installed, let’s choose our microservice.</p><figure><img alt="Screenshot of Codewind plugin panel in VS Code. The Project menu is shown with the Create New Project option selected" src="https://cdn-images-1.medium.com/max/453/1*j-4bzo8rmWFV_R2PKlHxiQ.jpeg" /><figcaption>Create a new project using Codewind’s project templates</figcaption></figure><p>A right-click on the Projects tree of the Codewind view in VS Code offers the option of creating a new project by selecting from a list of project templates. These templates cover several languages including Node.js, Java, Python and Swift, and several frameworks such as Express, Spring Boot and Open Liberty, with more on the way.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wC_jMtpuQNwiDr7WWUHQqQ.png" /><figcaption>Screenshot of Codewind for VS Code, showing a few of the many project templates available</figcaption></figure><p>As soon as you select the template, <strong>Codewind will automatically build the project and run it in a container, </strong>in this case hosted by your local Docker Desktop.<strong> </strong>And that’s it! You’ve got a running containerized application! Congratulations!</p><p>Ok, so what about the container itself?</p><h4>2. You can probe and take a look inside your container <em>without</em> having to leave VS Code</h4><p>By integrating with VS Code’s terminal window and output panels,<strong> </strong>Codewind enables you to<strong> </strong>view your container’s logs, run docker commands to get detailed information on the containers and run commands from <em>within</em> the container, all from the comfort of your IDE.</p><p>Taking a look inside your container couldn’t be easier — <strong>just right-click the project in the codewind project tree to open a shell into your container</strong>. Job done.</p><h4><strong>3. Want information on your microservice?</strong></h4><p>Use Codewind’s Project Overview feature to instantly view the location of the endpoint, the container ID, location on disk, build and run status, and ports.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/789/1*EEoe8KtQ7CtgwBYQ5IILWA.png" /></figure><p>You also have the option to build, remove, or disable your project from this panel. Simply click the information icon located next to your project listing in the Codewind view project tree to open your project’s overview window.</p><h4><strong>4. Viewing your microservice endpoint is also just a click away.</strong></h4><p>Navigating back to the project’s listing in the Codewind view project tree, this time click the Open External Site icon,<strong> </strong>and the endpoint is opened in your default browser.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/856/1*ixbcJpJHVczrs2NpirOGLw.png" /></figure><figure><img alt="Browser endpoint of the node.js express Codewind template" src="https://cdn-images-1.medium.com/max/287/1*jHVRjAna4pX-UeaxodypqQ.jpeg" /></figure><h4><strong>5. Make a change to your code and watch Codewind implement these changes intelligently</strong>.</h4><p>Codewind automatically rebuilds your code changes, redeploying as efficiently as possible. You can see the automatic restart in action by watching how the project’s build and run statuses change in the Codewind project listing view.</p><h4><strong>6. Additional features</strong></h4><p>Codewind has many other features that make for a smooth inner loop experience, which include:</p><ul><li><a href="https://youtu.be/nfJt3f5TUvc">application and performance dashboards</a> that allow you to observe real-time changes and improve your code as you develop</li><li>full compatibility with the Debug functionality of VS Code.</li><li>ability to open your own containerised projects in Codewind and use Codewind’s development environment features</li></ul><h4><strong>Fancy a go?</strong></h4><p>Experience what the <a href="http://codewind.dev/">Codewind</a> integrated container development experience can do for you by downloading Codewind from the <a href="https://marketplace.visualstudio.com/items?itemName=IBM.codewind">VS Code</a> or <a href="https://marketplace.eclipse.org/content/codewind">Eclipse marketplace</a>.</p><p>Watch Codewind in action and subscribe on our <a href="https://youtu.be/mjADP2_4FBg">Youtube Channel</a>.</p><p>Have questions or feedback? We’re all ears. L<a href="https://mattermost.eclipse.org/eclipse/channels/eclipse-codewind">et us know what you think</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5bf7c35f0c80" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codewind/want-to-get-a-microservice-up-and-running-super-quickly-try-codewind-5bf7c35f0c80">Want to get a microservice up and running super quickly? Try Codewind.</a> was originally published in <a href="https://medium.com/codewind">codewind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Checking Node.js sub-dependencies licenses for usage and redistribution]]></title>
            <link>https://medium.com/codewind/checking-node-js-sub-dependencies-licenses-for-usage-and-redistribution-58fe70a77847?source=rss----8b4ff73e9142---4</link>
            <guid isPermaLink="false">https://medium.com/p/58fe70a77847</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[licensing]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Nik Canvin]]></dc:creator>
            <pubDate>Wed, 30 Oct 2019 15:32:00 GMT</pubDate>
            <atom:updated>2019-11-04T10:02:55.182Z</atom:updated>
            <content:encoded><![CDATA[<p>Reusing Node.js modules from NPM is technically easy, but understanding the commercial legal usage and redistribution implications can be a ‘black art’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/354/1*Pl2ZekqJDQTkLCz5Wjw0pA.png" /><figcaption>‘npm list’ ... then scroll and scroll and just keep going</figcaption></figure><p>Working as a software project manager for the last 2 years on an offering which uses 1000s of open source packages and releases every four weeks, I’ve spent considerable time discovering, understanding and manually working through several pain points regarding open source (OS) sub-dependency identification and licensing challenges.</p><p><em>Note: In my case I needed automation to keep up with both my project’s consumption of new OS packages, as well as the OS community’s appetite to continuously update their packages. A new microservice was developed for use by my team, which I’ve shared in a separate blog here: “</em><a href="https://medium.com/@Nik_D_C/a-microservice-to-provide-node-js-sub-dependency-license-insights-using-eclipse-codewind-7576c6535f2f"><em>A new microservice to provide Node.js sub-dependency license insights</em></a><em>.”</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qqUAZclfyx4zmdP7uuVG9A.png" /><figcaption><em>Enter a package name and version to check (left window) and license results (right window)</em></figcaption></figure><p>However, for anyone in a sinking ‘sub-dependency nightmare’ boat and without a magic microservice, the main purpose of this blog is to share the four main pain-points I encountered and the approaches I learned to overcome them.</p><h4><strong>Pain point 1: Developers start using open source sub-dependencies that have inappropriate license</strong>s</h4><p>When choosing open source, developers usually focus on capability and community popularity (downloads), then the declared license provided and maybe top level sub-dependency license compatibility, but unforeseen legal issues/risks buried deeper in sub-dependencies may surface late in the development process, causing the following:</p><ul><li>Best case: wasted time (developer, code committer, IP attorney, project manager), to assist with investigation and/or mitigation.</li><li>Medium case: removal of the offending open source, leading to reworking code, wasting time and delaying feature release (maybe even contamination of the developer environment if wrongly downloaded).</li><li>Worst case: loss at legal litigation with executive level consequences.</li></ul><p>Should the developer either directly or request management to investigate the potential use of a package with sub-dependencies, then there is no quick easy way to overcome the following three additional pain-points.</p><h4><strong>Pain point 2: Compile an accurate listing of ‘production’ sub-dependencies with versions</strong></h4><p>There are several things to consider here:</p><ol><li>In a multi-person development team, don’t ask multiple people to manually provide listings of sub-dependencies being consumed, as you’ll likely get an inconsistent set of packages/versions (see the following bullets), so it’s often best to go directly to the source code, understand how it’s built and do it yourself. The learning curve for a non-technical project manager is pretty low, so don’t be afraid.</li><li>If the offering is built, using ‘npm ci’ (clean install), then the sub-dependency tree used will exactly match the package names/versions listed in the project package-lock.json file.</li><li>If the offering is <strong>not</strong> built using ‘npm ci’, then the actual versions used are generated at install time following semantic rules in the package.json instead. In this case, good automation is key to ensure when you release you can quickly provide the most current license and copyright notices possible.</li><li>Also when doing the ‘npm install’, using the ‘-production’ flag will make sure only production dependencies (not development only dependencies) are installed, as those are the ones that commercial offering license and notices files need to cater for.</li><li>If your offering spans multiple code repositiories (such as git repos), make sure you know which are the ones that will be used in the actual offering build. Large offerings with distributed agile development teams often spawn many repositories, which can easily become obsolete or even never contain final offering code.</li><li>Delta processing (only handling what’s changed since the last release) is a common approach to minimise pain, however, this can all too easily result in missed packages never being picked up in the future.</li></ol><h4>Pain point 3: Compile an accurate understanding of sub-dependency licenses and copyright notices</h4><p>Again this is not quite as easy as it sounds:</p><ol><li>The good news for Node.js is that the community is good at declaring the license for a module in the package.json. I used a ‘<a href="https://www.npmjs.com/package/license-checker">license-checker’</a> module on NPM, which does a great job reporting the declared license and in the absence of a declaration, it parses targeted files and guesses the license.</li><li>However, it’s possible that code under less commercially redistribution friendly licenses lurks in package files, so it is advantageous to check all files for ‘risky keywords’ such as ‘GPL’.</li><li>Some packages release under ‘dual’ license terms, so you need to do your due diligence to ensure that you can use a package under the accepted license terms for your offering.</li><li>Each of the cases above can require manual investigation, so rediscovery of risks and issues can result in wasted time, especially when packages with trickier cases release frequently.</li></ol><h4>Pain point 4: If you are required to follow a legal IP clearance process*, then ensuring only previously uncleared packages are checked and cleared</h4><p>*An example ‘legal IP clearance process’ is the <a href="https://www.eclipse.org/projects/handbook/#ip">Eclipse IP process,</a> which is required for Eclipse projects.</p><p>I found the tricky parts here, are:</p><ul><li>Maintaining a list of package versions previously cleared, then using it to help developers choose which open source packages to use in future <strong>and</strong> also when processing previously uncleared packages at release time.</li><li>When producing the final offering license and copyright notices for a release, then all the packages present should be included, not just the delta in the bullet above. You should also be able to exclude any packages no longer present since the last release.</li></ul><h3>In summary</h3><p>As the use of open source continues to balloon with the exponential growth of sub-dependencies (see this 30 billion monthly downloads <a href="https://blog.npmjs.org/post/180868064080/this-year-in-javascript-2018-in-review-and-npms">NPM blog</a>), coupled with the need pick up the latest security vulnerability fixes in the latest package versions, automation is the obvious way to ensure any subsequent legal risks are consciously mitigated.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GK1gGpyEFf87E0Ra1zToiQ.png" /></figure><p>Using the <a href="https://www.eclipse.org/codewind/">Eclipse Codewind</a> developer tools, the automation in this case was implemented as a microservice to enable the widest possible reuse within my company, either as-is or as part of other parties’ automation workflows. Find out more in this related blog: “<a href="https://medium.com/@Nik_D_C/a-microservice-to-provide-node-js-sub-dependency-license-insights-using-eclipse-codewind-7576c6535f2f">A new microservice to provide Node.js sub-dependency license insights</a>.”</p><p>Node.js is not the only language with challenging sub-dependency package identification and licensing risks, so similar work drilling into other languages is in progress.</p><p>As checking Node.js sub-dependency licenses and copyrights is only part of the legal work required for typical release (other work being to check for other language packages, as well as creating final license and notices files), further microservices are also in progress to automate many other legal and non-legal offering release steps.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=58fe70a77847" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codewind/checking-node-js-sub-dependencies-licenses-for-usage-and-redistribution-58fe70a77847">Checking Node.js sub-dependencies licenses for usage and redistribution</a> was originally published in <a href="https://medium.com/codewind">codewind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A new microservice to provide ‘Node.js sub-dependency license insights’]]></title>
            <link>https://medium.com/codewind/a-new-microservice-to-provide-node-js-sub-dependency-license-insights-7576c6535f2f?source=rss----8b4ff73e9142---4</link>
            <guid isPermaLink="false">https://medium.com/p/7576c6535f2f</guid>
            <category><![CDATA[licensing]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[development]]></category>
            <dc:creator><![CDATA[Nik Canvin]]></dc:creator>
            <pubDate>Wed, 30 Oct 2019 15:31:02 GMT</pubDate>
            <atom:updated>2019-11-07T10:47:37.308Z</atom:updated>
            <content:encoded><![CDATA[<p>An overview and demonstration of a microservice that automates some Node.js sub-dependency management pain-points, developed using <a href="http://ibm.biz/eclipse-cw01">Eclipse Codewind</a>.</p><p><em>Note: I covered the pain points and manual remedies associated with Node.js sub-dependency identification and licensing in a </em><a href="https://medium.com/@Nik_D_C/checking-node-js-sub-dependency-licenses-for-usage-and-redistribution-58fe70a77847"><em>previous blog</em></a><em>. You may also be interested in a lower level technical autopsy of this containerized microservice in this </em><a href="https://medium.com/@Nik_D_C/a-technical-autopsy-of-my-containerized-node-js-1bbd686d721d"><em>next blog</em></a><em>.</em></p><h3>What does the microservice do?</h3><p>Once the user has submitted the Node.js package name and version to check, as well as the NPM install type (clean or not), the microservice downloads the entire package dependency tree needed for production use.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FzUiVekFCs-w%3Ffeature%3Doembed&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DzUiVekFCs-w&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FzUiVekFCs-w%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/c9841c45febfca061cf55392513306bc/href">https://medium.com/media/c9841c45febfca061cf55392513306bc/href</a></iframe><p>As the team initially using this microservice are releasing an Eclipse Project, they must follow the formal Eclipse IP usage clearance process. The first step to process the sub-dependencies, is to identify packages previously cleared for use, as no further action is required for those.</p><p>The next step to identify which software license each package has declared, so for this an open source <a href="https://www.npmjs.com/package/license-checker">license-checker</a> NPM module was reused. The licenses detected are then compared with a list of pre-approved licenses that the project may use.</p><p>An additional check is conducted at the package file level and scanning all the characters looking for risky keywords. This is to catch cases where the declared licenses not may have handled sub-licensed files within the package correctly. In our case we initially looked for instances ‘GPL’ strings, which was used to flag up commercial risks.</p><p>Finally a report is compiled and presented, which summarised what next action was required if applicable and sorted all the package results in a traffic light order:</p><ul><li>Red is used to indicate any legal license risks found.</li><li>Amber is used when no risks were found, but the specific package has not previously been approved for use on the project.</li><li>Green covered the case where the specific package has been previously approved for use.</li></ul><h3>Why was a microservice implementation chosen?</h3><p>There were many benefits using a microservice to solve this problem, including:</p><ul><li>The capability did not run on the users workstation, so the barrier to adoption was minimal (no install/setup is required). Also the myriad of sub-dependencies were not downloaded directly to the user, avoiding potential IP contamination edge cases.</li><li>Easy for other more extensive automation to elegantly reuse this single function. Development teams aim to automate as much end-to-end release process as possible, often resulting in unreusable localised coding of this type of function.</li><li>Easy to deploy to any Cloud. I used an instance of OpenShift running internally within IBM (so currently only IBM employees can access this microservice).</li></ul><h3>How was the microservice implemented?</h3><p>If you’re interested in a lower level technical autopsy of this containerized microservice then my <a href="https://medium.com/@Nik_D_C/a-technical-autopsy-of-my-containerized-node-js-1bbd686d721d">next blog</a> may be for you, but to keep things simple here’s a quick overview.</p><p><a href="http://ibm.biz/eclipse-cw01">Eclipse Codewind</a> was used to instantly create and run an empty Express Node.js containerised microservice in one simple step.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b98KAw8fTx5ZrtyEUMIrIg.png" /></figure><p>The application logic was iteratively added in Node.js and as Codewind automatically respun the running microservice from code level changes, progress was continuously validated between iterations.</p><p>Once complete, the containerised microservice was simply deployed to the Cloud of choice (an OpenShift instance within IBM in this case).</p><h3>Summary</h3><p>A previously laborious process of working out the software license legal risks for a Node.js package, has now been reduced to a simple self-service check for the Developers I work with on my offering. <a href="http://ibm.biz/eclipse-cw01">Eclispe Codewind</a> enabled a fully containerised cloud native microservice, to be quickly created and efficiently iteratively updated until it was complete.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7576c6535f2f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codewind/a-new-microservice-to-provide-node-js-sub-dependency-license-insights-7576c6535f2f">A new microservice to provide ‘Node.js sub-dependency license insights’</a> was originally published in <a href="https://medium.com/codewind">codewind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A technical autopsy of a containerized ‘Node.js dependency insights’ microservice application]]></title>
            <link>https://medium.com/codewind/a-technical-autopsy-of-a-containerized-node-js-dependency-insights-microservice-application-1bbd686d721d?source=rss----8b4ff73e9142---4</link>
            <guid isPermaLink="false">https://medium.com/p/1bbd686d721d</guid>
            <category><![CDATA[licensing]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Nik Canvin]]></dc:creator>
            <pubDate>Wed, 30 Oct 2019 15:29:31 GMT</pubDate>
            <atom:updated>2019-10-30T14:56:03.178Z</atom:updated>
            <content:encoded><![CDATA[<p>This blog focuses on the code to implement a cloud-native serverless Node.js microservice developed using Eclispe Codewind.</p><p><em>Note: To see a quick overview and demonstration of the running microservice from an end users point of view, you may like this </em><a href="https://medium.com/@Nik_D_C/a-new-microservice-to-provide-node-js-sub-dependency-license-insights-7576c6535f2f"><em>previous blog</em></a>.</p><p>An overview of flow and microservice files:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*W8CYCyM1lKxmbZHeSsXp7A.gif" /></figure><p>A more in-depth look at the key files in the microservice:</p><p>‘<strong>routers/processNow.js</strong>’ and ‘<strong>public/uploads.html</strong>’ files</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lsYj0hqHFeO2__lE5W0Atg.png" /><figcaption>code extract</figcaption></figure><ol><li>processNode.js defines the root ‘/‘ application endpoint, which loads the uploads.html form, from the ‘/public’ dir.</li><li>After the user has entered the details of the package name and version they would like to check, the community ‘<a href="https://www.npmjs.com/package/multer">multer</a>’ module is used to store the details in an ‘uploadData’ constant.</li><li>That constant is then passed to the following service for processing:</li></ol><p>‘<strong>services/handleUpload.js</strong>’ file (using asynchronous calls throughout to control the following work flow):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FHgFjdcjZZuE82YMQ0-_YA.png" /><figcaption>code extract</figcaption></figure><ol><li>Removes the packageDir if it pre-exists (makes sure we do a fresh check even if package name/version previously checked, in case and sub-dependency details have changed).</li><li>Creates working directories for the packageDir and an analysisDir.</li><li>Calls GetPackageAndDependencies which downloads and decompresses the package from NPM. It the calls CleanNodePackageInstall to install all the sub-dependencies. If the user specified a ‘clean’ install of sub-dependencies (default) and a package-lock.json exists, then NPM installs all the production sub-dependencies at the versions specified in the package-lock.json file. If not, then the none explicit semver versions declared in the package.json are used instead.</li><li>Calls PerformLicenseCheck, with uses the community ‘license-checker’ module to determine either the declared license for all production dependencies to a best guess by analysing a few targeted files.</li><li>Now it’s time to determine package usage safety. Initially, all packages are added to the ‘Green list’ (no further action needs to be taken), then the following steps are run to determine any increased usage risk level that is detected.It then calls CompareResultsWithExistingClearance which checks which packages have been previously cleared for use (this assumes the developer is part of a project following a formal IP clearance package approval process, such as the Eclipse Codewind project following the Eclipse IP Process). Any packages not previously cleared for use, are moved to the ‘amber list’ (warning users of packages not previously cleared).</li><li>Next os to call CompareResultsWithApprovedLicenses, which checks which packages are NOT licensed according to a pre-approved safe license type list (as above, this also assumes the developer is part of a project following a formal IP clearance package approval process, such as the Eclipse Codewind project following the Eclipse IP Process). Any packages without pre-approved license types are moved to the ‘red list’ (alerting users of packages with potentially blocking usage licenses). Finally is to check if any dependency files contain any risky secondary licensed code by calling ‘PerformGrep’, which spawns a child process to run a ‘grep command’ which scans every file in every package looking for risky non-case sensitive ‘gpl’ keyword. All results are passed too ‘ProcessGrepResults, which gets the line and line number of any risky secondary licensed code. It then calls CompareResultsWithGPLMentions, which moves any ‘amber’ packages to be ‘red’ packages, if risky keywords are found.</li><li>All the results are then sent to sent to ‘RenderPugResultsFile’ (see below) to format them as html</li><li>Then the html is returned to the users browser.</li></ol><p>‘<strong>results.pug</strong>’ file</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/856/1*px36Gru_pvg8JCVLV-eKHA.png" /><figcaption>code extract</figcaption></figure><p>1. A ‘results.css’ stylesheet is linked to help format the html<br>2. A banner is added, linking to the ‘Eclipse Codewind’ page and the specific OpenSourceUsageManager’ project GitHub page <br>3. Then a summary of overall results is displayed<br> 1. If packages (on the ‘red’ list) with issues were found, then an alert immediately informs the user.<br> 2. Else if packages (on the ‘amber’ list) with warnings were found, then this is conveyed to the user.<br> 3. Else a ‘green’ bill of health informs the user that they may use their package without further action. <br>4. Then in a collapsable format, first all the ‘red’ packages are displayed (with a drill to salient comments), then the ‘amber’ ones and finally the ‘green’ ones at the bottom.</p><p>To get a new containerized microservice up and running immediately without any Kubernetes or Docker skills at all, I used Eclispe Codewind. See this <a href="https://medium.com/codewind/introduction-to-eclipse-codewind-build-high-quality-cloud-native-applications-faster-44484a02b465">introduction</a> to follow in my footsteps.</p><p><strong>All projects created using the Eclipse Codewind Express Node.js project template that I used, contain the following key files:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/895/1*6DGOjUCU_LjzTp-2wsxqww.png" /><figcaption>code extract</figcaption></figure><ul><li>A ‘<strong>dockerfile</strong>’ which drives the docker build process when Eclipse Codewind containerises the application. It defines the base operating system (node:12-stretch in this case) to put in the container and updates all the operating system dependencies. It then copies all the application root files into the container, installs all the application sub-dependencies (node modules in this case), configures/exposes port 3000, then starts the application in the container.</li><li>A ‘<strong>server.js</strong>’ file which creates the ‘express’ server and defines an ‘appmetrics-dash’ endpoint that Eclipse Codewind uses to visualise application metrics such as CPU, memory and http response time/throughput.</li><li>A ‘<strong>router/health.js</strong>’ file which defines a ‘/health’ endpoint which displays a ‘status: ‘UP” message and is used by Eclipse Codewind to determine if the app is running.</li></ul><p>Two other noteworthy features (available by right-clicking a project in Eclipse Codewind) that were used to ensure the microservice delivered acceptable behaviour and performance that come built in with Eclipse Codewind are:</p><p><strong>Application Monitor</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*Zn9UV0ddVZhLJVhwsU1uig.gif" /><figcaption>realtime metrics for a running containerised application</figcaption></figure><p>This was used to check CPU, memory and http metrics during development iterations, to ensure nothing untoward had occured in the latest code changes.</p><p><strong>Performance Dashboard</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K6xn0mBceertf0jl66kdew.png" /><figcaption>The performance dashboard</figcaption></figure><p>This was used to drive simulated load through the microservice to check overall throughput performance. Several runs were stored and compared during development iterations and to verify the final code.</p><h3>In a nutshell</h3><p>Using the <a href="https://www.eclipse.org/codewind/">Eclipse Codewind</a> develop tools instantly created a fully formed and started containerized Node.js microservice application, doing all the heavy containerization lifting automatically.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MIzncvlT4w9iOk2Tzik3wA.png" /></figure><p>The application was completed by adding the code in files described above.</p><p>To see the final microservice in action, you may like to visit this previous blog: “<a href="https://medium.com/@Nik_D_C/a-new-microservice-to-provide-node-js-sub-dependency-license-insights-7576c6535f2f">A new microservice to provide ‘Node.js sub-dependency license insights’</a>”</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1bbd686d721d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codewind/a-technical-autopsy-of-a-containerized-node-js-dependency-insights-microservice-application-1bbd686d721d">A technical autopsy of a containerized ‘Node.js dependency insights’ microservice application</a> was originally published in <a href="https://medium.com/codewind">codewind</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>