Software Development, tools

Dev Tool: Atom – Revisited

Atom is Github’s hackable text editor. I was introduced to it by a friend in college. Since then I have used it for various tinkering projects in Python, and an Arduino project with a couple of friends. Atom is awesome!

Atom doesn’t ship with support for everything, which is alright. But what makes Atom great, is that it is extensible! It has a rich marketplace of published extensions offering support from Python to C, and Json to Yaml. I discussed some of the packages that I used to support both python and Arduino in my previous post.

Lately, I have been using Atom as my go-to REPL environment. Now, there are other tools like, which are great for rapid feedback tinkering. However, I always feel … iffy about online solutions. They can be great, but if the power is out, or the internet is down, or worse slow… well there go the advantages.

But last week, I started to notice that my instance of Atom was starting a bit slow. Mind you it was just a few seconds, but it was noticeable. So I started hunting. After a while I found that Atom ships with a plug in called Timecop. Timecop tracks performance times of the modules that you have installed and active. It tracks the load time, the init time as well as other associated metrics.

As I started snooping I found that several of my modules were really slowing me down. For example, a bit more than a half second was lost to Omnisharp, which I had loaded to support C# tinkering. Additionally the C Language Linter Library also ate considerable time.

C and C# are not the fastest REPL languages for me. As a result, I decided to pare down the modules that I had supporting them. Now don’t get me wrong, I love C# for business development! I just feel that it can be cumbersome for REPL workflows. So, I uninstalled some of my modules, like Omnisharp. But for C, I just deactivated them. This is because C is often used for Robotics and Arduino Associated applications.  Since the modules were still installed, I could turn them back on. Thus the features can be used without incurring the start-up cost every time I launched Atom.

All in all, this was an interesting exercise, and I thought that others might benefit from hearing about it. I am rather pleased with the results. And after gaining this experience, I am think that my next challenge will be to write a plug-in or module myself! I recently found this tutorial that I think will help.

As always thanks for your time! If you found this post interesting, I would encourage you to check out my personal blog. I have several posts on Development Tools that I think you might like!

This was originally posted on LinkedIn with the Title Dev Tool: Atom. Since that was the original post’s title, I have changed it. Further, this post originally refered to the plugin as Timeit. I discovered later that was incorrect. I have applied this correction here.

Software Development

Development Tool: Atom

atom-iconA few years ago, just before I left college, a friend introduced me to a funny little program called Atom. It was billed as a ‘Hackable’ text editor. At the time I thought it was an interesting little toy, and tinkered with it for a while. But since I didn’t find any real use for it at the time, I was satisfied with just tinkering. Over time, as classes became more demanding I kind of left it behind. That is until I found a convincing use-case for just such a program!

Recently, I have picked up Atom again for a personal project with some church buddies of mine. We are working with an Arduino and several external components. Since there are three developers and two or three operating systems between us, I wanted to get a product that we could all use with ease on any system. I settled on Atom after becoming frustrated with the existing Arduino IDE.

Since our project had three developers, we split the responsibilities into three primary areas, and had organized our project files accordingly. However, the Arduino IDE does not support a nested architecture, and instead needs all the files to be present at the highest level. Not wanting to lose the project organization, I started dabbling with Atom and found its support to be far superior to the Arduino IDE for this project.

Of course, nothing is perfect, and Atom does not ship with built in support for the Arduino. Thankfully there are a couple of packages which provide the necessary components for it. They are Platformio, and the language-arduino packages. Now, Platformio did require that we adjust our project architecture so that the compiler could locate all our file, this is a very small change, and allowed us to continue more-or-less un-phased. Furthermore, the Platformio package also supports other boards than the Uno which our project was using.

So, after playing with Atom for a week or so, purely for my Arduino project, I became more familiar with the various features, and I was able to get more comfortable with the shortcuts among other things. After a while, I switched back to one of my python projects, and had a little shell shock. At present, I am using PyCharm, which has severed me well, and has the added benefit that one of its default settings allows the Microsoft Visual Studio shortcuts to be used. It is quite polished, and provides solid support for most anything a developer could want to do in Python. But it’s not very easy to customize, at least not compared to Atom.

n the flip side, Atom doesn’t ship with support for running python scripts from the IDE. But it does include some language highlights. Here again, the Package system comes to save the day. With the Script Package, Atom gains the ability to execute both Python and other interpretive languages, like Julia , and can display the feedback via an in-IDE terminal window! Furthermore, with Atom, the error highlighting is fairly descriptive, and will show the developer the breaks for the current document! So by switching between various files in your project you can see the pertinent errors in each file, without having to browse through an exhaustive list contained every file all together! Which, coming from a C++ project, is pretty great!

For a little icing on the cake, Atom also has a fair bit of Git integration. (I should hope so, considering it is Git’s IDE). The projects nicely highlight new, and changed files from the current Git changeset, and the default settings are programmed to reduce the clutter in the project view, by leaving out the various .git files, like the .git-ignore. This is a pleasant feature, which I have enjoyed for my Arduino project.

Overall, Atom is a very impressive program. It can be as simple or as advanced as you need it, and can change with ease to suit your needs, through their robust Package manager! With their wide community support base, I look forward to enjoying Atom for many years to come. For anyone interested in learning more, please check out Atom here!

*- Image borrowed from this

Software Development

Development Tool: Jupyter

Recently, one of my colleagues presented a prototype of a new feature that my team was going to implement. To be certain the new feature was fascinating both for its algorithmic complexity, and its significance to our users. However, I was admittedly more caught by the tool he had used to develop and present the prototype. With this tool he was able to set-up a development environment, test data, and was able to demonstrate live, working code for us with ease! This tool was Jupyter.

*Jupyter Logo

I can best describe Jupyer as a web-hosted development and testing environment. The Jupyter application is installed on a server which can then expose multiple notebooks wherein the development can be done. More specifically, these notebooks are where the demonstration data is housed, and the presentation are run. Moreover, each notebook can be hooked up to a different compiler/interpreter to allow development to proceed in multiple languages!

This is profoundly useful, because it allows a prototype to be developed in the easiest language to program in, without having to pay for the overhead of a presentation layer! Thus demonstrating a feature to the PM/PO becomes much easier! Furthermore, when you are presenting to the developers, they can make adjustments to the code which you are presenting and they can witness the change’s effects in real-time!

A Jupyter notebook’s structure is very similar, if not identical, to that of a Mathematica Notebook. In Mathematica, the user creates a notebook, and enters an equation , or series of equations into an entry. Then the computation is carried out for that entry, and the user can proceed to use the results in the next entry. This includes plotting as well as some algorithmic analysis, which is especially useful for complex physics simulations.

In Jupyter, the user enters a series of functions, function calls, or classes into an entry, which can then be employed for later use by future entries. One can execute an algorithm in one step, and plot it in the next, or go on to use the results of the algorithm in another step.

Each entry’s results are calculated based only on the present conditions, so changes to entry 1 might affect entry 5’s results, if entry 5 used entry 1’s results to calculate. But as a benefit, if a mistake was made in entry N, one need only correct that entry, and then re-run the calculations for the entries which follow. Both Mathematica and Jupyter share this behavior.

In a corporate setting Jupyter would excel in several use cases, including the PM/PO and the developer Demonstration. In a non-co-located, or even in a co-located environment, a Jupyter notebook could be set-up to allow many users to interact with prototypes in real-time, allowing developers to review the functioning of the prototype while they might be developing the code in a different location or language.

Alternatively, It could be used to allow the PM to visualize what a new feature’s output will look like given some sample data, without having to ask the developers to run the simulation! This would allow the PM to quickly sort through the accuracy of the algorithm. In this case, a QA could also use the notebook to actively investigate a customer reported error in the algorithm, so long as they have the important data and access to an updated algorithm. This way the QA would not need the entire user project, and all the sensitive information that might contain, which could make reproducing bugs much easier!

Finally, as was the case with my colleagues work, Jupyter can be used as a rapid-prototyping environment. Since the language compiler/interpreter are set with the notebook, and the presentation layer is already handled, the developer is much more free to pursue the real interest, the product algorithm. Since the language is not locked by previous work, the developer would be free to choose whatever language they felt would best suit the project. They could feasibly borrow data from other projects, or even simply generate it within the notebook!

Overall, Jupyter looks to be a very effective tool for sharing the development of algorithms, or other possible calculation intensive features in an accessible way with multiple parties within the organization. It provides a usable interface to both developers and non-developers alike, in an approachable fashion. It provides the ability to modify the experimental data to give the users a more detailed understanding of the prototype. And finally, if it were used to hold the existing algorithms, then it might also allow the PM’s to simulate the program sufficiently to trace bugs related to the customer data, or to the company’s algorithm rather than wasting significant time in the back-and-forth as developers seek to understand the meaning behind the data, and why a particular output is wrong.

For those interested in knowing more, you can find Jupyter at! Thank you for your time, and I hope that you find this tool to be useful in your endeavors!

* The image shown is the Jupyter logo found on the home page.