Forem: Josh Pinkney

Tracking down the painful bugs

Josh Pinkney — Sat, 20 Oct 2018 22:06:41 +0000

A few months ago I was helping a co-worker fix a bug in the XML language server that had to do with the hover feature. The bug wasn't throwing exceptions, attempts to debug it yielded no results that were easily found and for some reason, the language server just kept crashing. It wasn't really clear at all what was happening and the code just sort of died. Since this bug was seemingly undetectable we spent a really long time (probably more then we should have) doing a brute force comment out of sections that we thought might have been causing the issue.

What's sad/funny is what was actually going on. For those of you who don't know, language servers connect to a client (such as VSCode) and VSCode sends requests to the server based on a user event. For example, if you hover over an element it sends a request to the server and the server sends a response back. The language server protocol dictates what should be sent/returned for a request/response. The bug was extremely simple and rather funny, but painful to debug. Basically what was happening was there was

System.out.println("test");

inside of the part of the server that controls what happens when you hover over an element. Since VSCode was seeing that we were trying to hover, it would send a hover request to the server. The server would then react but when it hit

System.out.println("test");

it was sending back "test" to the client, resulting in the language server crashing.

Let me know your worst bug experience in the comments!

My 16 Months at Red Hat

Josh Pinkney — Sat, 13 Oct 2018 01:54:04 +0000

The University of Toronto offers an internship program called Professional Engineering Internship (PEY). Each year students join a company for 16 months to gain experience (either in Software Development or a few other fields). Last year/this year (May 2017-August 2018) I did my internship with a software company called Red Hat. Red Hat is a company that contributes a ton to different open source projects (you might know them for Fedora or RHEL). All of the interns were assigned a different open source project to work on. In my case, I worked on quite a few different things mainly the YAML Language server, Eclipse Che, and Eclipse Theia.

Initially, I began working on the YAML Language Server for YAML files. For those who are not familiar with language servers, it is basically a language smartness provider to integrate features like autocomplete, go to definition, find all references and alike for programming languages or file formats[1]. Language servers work through the language server protocol which specifies which data will be sent to the server during different events. Additionally, it defines which results will be sent back from the server to the client as a response. For example, if you are editing a YAML file and you want to autocomplete at a specific location, the client is going to send a completion request to the server and the server will respond with valid completions. I worked on the YAML language server project mostly alone so I was responsible for creating all of the features (hover, validation, auto-completion, etc). It took about 4 months until release and has been steadily growing in downloads ever since. I'm currently working part-time at Red Hat so I still maintain it.

After the YAML Language Server was released I started working on Eclipse Che. For those who have not experienced Eclipse Che, it differs a lot from traditional desktop Eclipse (they're two completely different products, they're both just under the Eclipse foundation). For one, Eclipse Che is a cloud-based workspace management tool and IDE. This means that you are able to access your workspace/code from anywhere at any time in your browser and offers docker images with everything installed so that you will not have to do any configuration for your IDE. On the other hand, traditional Eclipse is an extremely heavyweight IDE. It has been one of the leading Java IDE’s for more than 10+ years, has a diverse set of features and focuses only on the desktop environment. Most of my work for Eclipse Che focused around language server integrations and making sure the predefined stacks were working correctly. In order to make sure the predefined stacks were working I had to learn a lot of docker and understand the requirements that were needed in each docker image. For example, for the Java stack, we'd want to make sure that the image its using has the latest java tooling installed. In terms of language server integrations for Eclipse Che, I specifically worked on and currently maintain the YAML Language Server integration and helped out with the Java Language Server integration.

Right now I currently work on Eclipse Theia. Eclipse Theia is also a cloud ide but differs from Eclipse Che in a few different ways. Eclipse Che is a very heavyweight IDE and built using Java while Eclipse Theia is lighter and built using typescript. Additionally, Eclipse Che is a workspace management + IDE combo whereas Eclipse Theia is only an IDE. Eclipse Theia is based off of Monaco (the editor that powers VSCode) and is currently on track to emulate the VSCode API inside of Eclipse Theia. This means that one day you should be able to run your VSCode extensions in the cloud. In terms of my work, I mostly work on additional Java support by adding features such as the ability to see external Java libraries, configuring your classpath, find implementation of interfaces. More recently, I've been asked to help emulate one of VSCode's endpoints inside of Theia.

Links for the curious:
[1] - https://langserver.org

https://microsoft.github.io/language-server-protocol/
https://github.com/redhat-developer/yaml-language-server
https://github.com/eclipse/che
https://github.com/theia-ide/theia

Introducing the XML Language Server!!!

Josh Pinkney — Thu, 04 Oct 2018 05:47:01 +0000

For the past 6 months or so some of my co-workers at Red Hat have been working on a language server for XML. This has been a heavily requested language server with a few attempts, but all of them only had basics features. As someone who is really fascinated with language servers its awesome to see another new one come out, especially one that I got to watch grow from inception. It just released on the VSCode marketplace a week or two ago and its really exciting to see the impact it has on writing XML.

The current features are:

Syntax error reporting
General code completion
Auto-close tags
Symbol highlighting
Document folding
Document symbols and outline
Renaming support
Document Formatting
XSD validation
XSD based hover
XSD based code completion
Code actions

It is still being actively developed and if you would like to check it out here's a link: https://github.com/angelozerr/lsp4xml

Building a Top 50 VSCode Extension that hit over 2 Million Downloads as an Intern

Josh Pinkney — Sat, 29 Sep 2018 05:45:49 +0000

It's been over a year since I started working on the YAML language server and VSCode-YAML and I thought it would be interesting to write about how it grew from hundreds of downloads per version to hundreds of thousands of downloads per version by sheer luck and a bit of perseverance.

Backstory

At the start of my internship at Red Hat, I was asked to work on YAML tooling specifically for Kubernetes. I was told that the tooling would leverage the language server protocol and we would write integrations for a couple of code editors, starting with VSCode.

The initial idea was to create a Kubernetes language server that would take out some of the pain associated with writing Kubernetes YAML files. We would do this by providing features such as validation, auto-completion, document symbols, etc. As development furthered the decision was made to pivot to a general language server to support all of YAML and not just YAML for Kubernetes' specifically. As a result, we were able to introduce another new feature: validation via JSON schemas. This meant that users are able to insert their own custom JSON schemas and have their YAML be validated against it. In other words, you can use the language server to help write Ansible, Kubernetes, and Travis CI YAML files just to name a few.

Now that we've built the language server, we needed to integrate it into a code editor. We started with VSCode-YAML which is the VSCode extension that starts the YAML language server and exposes preferences to the users in VSCode.

After a few months of development, it came time for the release.

Release

Within a few weeks of the release, there were hundreds of new developers downloading the extension and a few bugs and feature requests being submitted to the GitHub repo. As the downloads grew, so did my responsibility. I not only had to maintain the existing functionality, but I also had to create any enhancements that users have requested and create new releases.

Initially, VSCode-YAML wasn't popular because of a competing extension on the VSCode marketplace at the time. The competing extension had around ~20k installs and it seemed like we weren't going to be able to compete. Luckily through the power of open source, I ended up getting in contact with that extension creator. In short, he told me that he wanted to pursue other projects and didn't feel like maintaining his work and that if our YAML language server supported document formatting then he would shut down his extension. After we started to support document formatting he unpublished. Out of sheer luck, it gave us enough momentum to become the recommended YAML extension to install on VSCode.

Within about a week we went from getting hundreds of downloads a day to thousands. First, our extension got on the marketplaces trending today, then the marketplaces trending this week, and eventually the marketplaces trending monthly. After that the extension took off, rounding out that version at roughly 155,000 total downloads. With sheer luck, we were able to take the extension from something that a few people used, to something that thousands use.

Currently the YAML language server is integrated into a few different clients that support the language server protocol. It was first integrated into VSCode via an extension, then Eclipse Che, then Atom, then Neo-Vim, and more recently Theia.

Check out VSCode-YAML on the Marketplace

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

VSCode-YAML and the YAML language server are still being actively developed. If you are interested in the project and would like to contribute let me know!

Also, if you're interested in this type of content please give this post a heart :)