The End...For Now

After the split of the OpenMRS group, Austin, Zach and I decided to work on the Transterpreter for the rest of the term. The Transterpreter is an open-source and highly portable virtual machine designed to exploit concurrency on embedded systems, for running process-oriented programs written in the occam-pi programming language.



Existing interfaces for working with the Transterpreter were not cross-platform, well maintained, or user friendly. The lack of an active community has left the project fairly stagnant. There is a need to create a new method by which users may ship to the server, receive the compiled code, and flash it to an Arduino. There is also a desire to renew the Transterpreter project, by revitalizing certain aspects of it in a way that makes it easier to work with and maintain.

The desired platform for implementation was in the form of an Atom package, as Atom is very well documented and maintained and widely compatible.

The basic workflow as per the design is as such:

• Toggle on Transterpreter plugin
• Specify arduino type
• Select desired project
• Package occam-pi files within directory (JSON)
• Ship to server
• 
  
• Receive compiled occam-pi from server
• Flash to arduino via AVRDUDE

Our lack of familiarity with the tools and environment that we were to be working in prevented us from generating a more detailed design plan, and our ideas of how we would implement certain aspects changed on multiple occasions throughout the work on the project.

Supported board types are retrieved from the server whenever the Transterpreter-plugin is made active via toggling on and clicking the Transterpreter logo.
We started with a package template generated by the Atom package creator. Tools used include: CoffeeScript, JQuery, Node.JS, AVRDUDE.

We used these tools to generate a JSON structure that allows for packaging of all code within the current open directory, specifying which file is the “main” file.
One of the major challenges we had during the implementation of the plugin was handling the way scoping works in CoffeeScript. This issue presented itself while we were trying to execute deactivation of the event listeners, in order to prevent repeated uses from repeating payload generations.

There are still some steps left to be completed in order for the plugin to become a fully-functioning solution.

Code to specify and retrieve contents of the "main" file for packaging to send to server
Changes made on the server side to reflect differences in the generated JSON structure between Plumb and the Atom Plugin.
Function to retrieve the returned code compiled by server
AVRDUDE program execution within plugin to flash compiled code to the arduino.

All in all I think that this was a great learning experience. The project was fun and interesting, and Austin, Zach, and Dr. Matt Jadud have been phenomenal to work with. 

A Post.

I'm alive.
I'm just a terrible blogger. 

Still working on Transterpreting, as before. The Atom plugin is moving along, but it has turned out to be more complicated than we had thought when we were beginning. 

Progress
So far we have 

• Made a request for configuration things from the server
• Received a response
• Made the response readable
• Put the readable response into a drop-down

It's not a great deal of progress, however we are working in an interesting environment that we don't have any collective experience with, and are using a language (Coffeescript) that we are not familiar with.

Issues
The most difficult component of our work on the plugin thus far has been figuring out how the Coffeescript is supposed to look. At times we have found ourselves trying to write something that is, in fairness, pretty much plain Javascript. 

There are several significant differences though, the primary being that there are no "extra" characters, ever. Meaning: semi-colons, brackets, braces, etc. If there is some character you want to type because of formatting, don't. It won't work. The language is dependent upon indentation, much like Python. 

Which is kind of gross. It is what it is.

So, we continue forward.

-Craig Warner

Blogterpreting

Boogity Boogity Boogity
I actually hate NASCAR.

Clearly there has been a lack of vigilance on my behalf in terms of this blogging business. C'est la vie, what's done is done, the past is over and we have only the present to concern ourselves with.

Cool.
 
Plugin

Work is now underway. In Austin's absence today (good luck interviewing) Zach and I changed direction a tad. Instead of building out a large JSON structure to represent what the server expects to be sent, we have started on the process of retrieving configuration information from the server.

We have also tried to make some concrete design decisions. The conclusion we came to is that we would like to have a modal pop up when the Transterpreter logo/button/thing is clicked. This modal should contain some method of identifying and selecting the board the user has and a giant button that says "TRANSTERPRET" in the middle. This button will package and send the appropriate information to the server to be compiled and given back.

It's all very exciting stuff, I promise. We will have to talk to Austin over the weekend to identify a more concrete plan for the final stretch of the course, but for now we will continue work to this end.

-Craig
 

FOSSEng Episode Something: A New Hope

It's alive.

Unlike everything else I have worked on so far in this course, getting everything set up to work has been very simple. Austin created a new plugin through Atom, which is beautifully simple, and put it in a repository on GitHub. Wonderful.

One of the major struggles that OpenMRS presented to us was installation. Installation. We couldn't even get the thing running to begin with for quite a while, and when we did we realized that we were using the wrong version of the system to do the work we intended to do.

Atom, on the other hand, is a breeze. It is a wonderful piece of software, and we are all happy to be taking our first steps in our work with the Transterpreter in something so nice to work with.

Moving Forward

At first we thought that the plugin would be very simple. We came to realize, however, that the Transterpreter is a bit more complicated than we thought. This should be alright though, as Dr. Jadud has been heavily involved in its development and will hopefully be able to provide us with some assistance.

We'll see how it goes. Wish us luck.

-Craig

The Ol' Switcheroo

The tables turned truly this time.

Alliteration is cool. Like bow-ties and fezzes...

Anyways, back to it. As I was saying, there have been some big changes recently. 

Following an uneventful 'SPRANG BREAK' there was a total dissolution of the Software Engineering class' OpenMRS team. We have unanimously decided that it is our best interests to pursue work in other projects for the duration of the term.

I am elated.

The Future

The group has split and taken several different paths. Some of us are joining existing groups that have already been working on their project.

Others of us have chosen differently.

Introducing...The Transterpreter

Sounds very exciting, right? This project is somewhat beyond my understanding in its totality at the moment, however it may be summed up in one word: Parallel. It is a piece of software that allows for concurrency on platforms such as the Arduino.

Don't expect too much depth here. This is about all I have in memory from class discussions on Monday. Perhaps I should have done this sooner. Perhaps.

As a first step, we are pursuing the development of an Atom plugin for the Transterpreter. Atom is pretty sweet, and we are looking forward to exploring this space and digging deeper.

-Craig

P.S. Where are my manners? This royal 'we' I have been using throughout consists of Zach Ball, Austin Farmer, and myself. 

The Rut

Hail.

I mentioned to Austin that I have been contemplating switching projects. He opposed. I probably won't be switching.

Curse you, Austin.

OpenMRS Stuff

I have managed to (finally) put together a working environment. In the words of fictional guitarist Toki Wartooth, in his infinite wisdom, "Woweee." This is one of the reasons that I have moved away from the thought of switching. 

I am now in a place to finally begin work on things, and it feels good.

Now I am working on properly installing and tinkering with the XForms module so that I can work on the issue that David and I identified as a first step into working on OpenMRS. It seems to be a baby bug, and a fairly old one at that, but it should help us to get our feet wet.

Unfortunately, I can't seem to figure out how to install modules at the moment, but if I can get that squared away then we will be good to go.

Maybe.

-Craig

Talks and Ships and Things

Today has been interesting indeed. 

Lightning Talks

All of the groups in the course did short presentations in class today. As I understood, they were to cover three key points:

• What we have done
• Where we are at
• Where we are going

The goal was to have determined an issue within our project to begin working on, and to have a plan of action to start.

These presentations were enlightening, as they helped me to get a clearer picture of the progress that the other groups have made thus far and how the work has been. They also highlighted some major differences in the projects that the groups are doing, which will be something to think about moving forward.

Abandon ship?

Towards the end of class, Dr. Jadud raised a compelling thought for those of us in the OpenMRS team. As the process thus far has been so troubling, some people working on OpenMRS have expressed interest in the possibility of switching to a different project. Dr. Jadud openly supported the idea of switching, and any groups have until Spring Break (Friday) to determine whether or not they would like to switch.

I myself have not completely given up hope on OpenMRS, but I am considering it. With so many problems in such a gigantic and varied project, I wonder if I may find work on another project to be more fulfilling. 

I'm considering it, but we will have to see how the week progresses.

-Craig

I Abide

In the words of The Dude:
(warning: language)
https://youtu.be/gbIv7W7rhx4?t=36s

We have now reached out to the community in various ways, and we are finding out that everything that we have been doing is incorrect.

Everything

So, according to information that has been gathered, we have been urged to move our efforts away from the OpenMRS core. Instead, we should be using the standalone application. Doing so, we will be able to work against individual modules and use the standalone as an engine of sorts, instead of trying to build and configure the entirety of OpenMRS just to test against modules.

This should speed things up significantly. In the course of today's class we have most of the OpenMRS team on the same page, to my knowledge. It should be a very brief process for us to all get started and working on a specific issue, which is very exciting considering all of the difficulties thus far.

Briefly, the Process:

Set up is very simple for a Ubuntu.

You will need:

• Vagrant
• OpenMRS Reference App: https://github.com/openmrs/openmrs-distro-referenceapplication
• VirtualBox
• Maven

Just check out the OpenMRS Reference App from GitHub, cd into the directory, run "mvn clean install" and then run "vagrant up".

Done. That's it. It will install everything else that you need, including the image for Ubuntu 12.xx (which Austin and I found to be interesting at the least). We only wish we had known this sooner. 

Now that I have written this out, I have managed to stumble across a more comprehensive guide on the documentation wiki. How silly of me. At any rate, there is much to be done by Monday and this post should have been finished sooner, but it is what it is. You know what they say (warning: language).

Like, Another Post: Community Things

Aloha

The illness has passed, and I feel like a new person. How wonderful. However, hat is neither here nor there.


Internets please, b0ss
Although I wasn't able to attend class yesterday, I feel as though it is safe to say that we have, as a collective, been working on initiatives to promote a kind of "conservation" of network resources at the college since last Wednesday. The reason for this shift in our focus is simple: massive consumption of bandwidth by the students for leisure activities is causing severe issues in our connection to the outside world. I guess. There is a clearly a lot to be understood about what exactly is causing network issues on campus, and this is the angle that my classmates and I are most able to approach with solution. 

Therefore, the class has decided that it would be valuable to take time out of our regularly scheduled programming (that was a pun, friends) and attempt to address the issue with the student body.

Our aim is to push our fellow students to adopt a more thoughtful culture concerning network usage, in which they are conscious of the limits of the college's resources and adjust usage in a manner that allows essential systems to work with efficacy. To accomplish this goal, we have been split into four groups, each with a different priority. I chose to work with the group responsible for communications with administration and offices around campus, in order to do things. Things like dissemination of information that may be useful for the students. Missing class yesterday has really put me out of the loop, if that isn't obvious. 

I'll be reporting further on these events as they unfold.

OpenMRS: The Enemy
NOT REALLY
As we continue working on OpenMRS, we are getting nearly everyone built and ready to work, in my knowledge. Again, I'm a tad hamstringed by my absence yesterday. Who knows. I've been exploring a bit through the community and issue tracking for the project, but I haven't put together a module yet for my own exploration and I should probably do that.

Some more things. It's an interesting morning.

-Craig Warner

Build Success: A Guide to OpenMRS

Ahoy

After all of my unusual troubles, I have finally done it. I have succeeded in building and installing OpenMRS on my Ubuntu machine. This blog post will serve as a guide, tracing the steps that led to my successful installation.

Before we begin, however, it's important to note that my machine has a 64-bit Intel processor and my operating system is Ubuntu 14.04.

Software
First, here are a few URLs for the resources that I used:
GitHub repository for the OpenMRS core

• https://github.com/openmrs/openmrs-core

Apache Maven version 3.3.9 tar

• http://apache.arvixe.com/maven/maven-3/3.3.9/binaries/apache-maven-3.3.9-bin.tar.gz

and Java 8 JDK

• http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

Note: the Java link features many different packages. We will need this one: jdk-8u73-linux-x64.tar.gz

You will also need to have a working version of MySQL installed on your machine, and you need to know the password for your user.

Installations
Note: You may have to run some or all of these commands as sudo. I did.

OpenMRS-Core
To check out the OpenMRS core, you will need to fork the repository. Once that is done, you can enter the following commands in your terminal to get the repo on your local machine:

$ mkdir openmrs-core

$ cd openmrs-core

$ git init

$ git pull *enter the URL of your forked repo here*

You should now have the checked out code on your machine.

Maven

Once you have downloaded the tar package, you can run these commands to get it running:

$ mv apache-maven-3.3.9-bin.tar.gz /opt/apache-maven-3.3.9-bin.tar.gz

$ cd /opt

$ tar -xfvz apache-maven-3.3.9-bin.tar.gz

$ rm apache-maven-3.3.9-bin.tar.gz

Now you will have the most recent version of Maven, as I write this, in your /opt directory. To make Maven easy to use, we will have to symbolically link to it, more or less making a "shortcut." To do this, enter:

$ cd ~

$ ln -s /usr/bin/mvn /opt/apache-maven-3.3.9-bin.tar.gz

Java

Download the tarball specified above, then follow these steps:

$ mv jdk-8u73-linux-x64.tar.gz /usr/lib/jvm/jdk-8u73-linux-x64.tar.gz

$ cd /usr/lib/jvm

$ tar -xfvz jdk-8u73-linux-x64.tar.gz

$ rm jdk-8u73-linux-x64.tar.gz

$ update-alternatives --config java

After the last command, you will most likely get a list of options. You want to make sure that you select the option that reads "/usr/lib/jvm/java-8-oracle/jre/bin/java"

BASHRC
Now we will have to add these programs to our path. To do this, you will have to 

$ cd ~ 

and, using the text editor of your choice, add the following lines to your .bashrc file:

#java home path
export JAVA_HOME=/usr/lib/jvm/java-8-oracle
export PATH=$PATH:$JAVA_HOME/bin

#Maven path
export MAVEN_HOME=/opt/apache-maven-3.3.9/bin
export PATH=$PATH:$MAVEN_HOME/bin

Once the above lines have been added the the .bashrc file in your home directory, enter the command

$ source .bashrc

to update.

Building OpenMRS
You should now have all of the necessary tools to build and install openmrs-core. To do this,

$ cd *file path to your openmrs-core clone*
$ mvn clean install

Make sure that when you run the clean install command that you are in the outermost layer of the openmrs-core directory. This may take a while, but that's ok. If you experience failure, try running the command as su. If you continue to experience failure, you may need to clear your .m2 folder, like so:

$ cd ~/.m2
$ rm -r repository
$ mkdir repository

After this process, try the "clean install" command again in the openmrs-core directory.

At this point, you should be able to run the installation. 

$ cd *file path to openmrs-core directory*/webapp
$ mvn jetty:run

Then, direct to your browser to "localhost:8080" You should be provided with a link. Follow the link, and click the button to install OpenMRS. Make sure that you have MySQL installed and that you know the password, as this installation is going to build the OpenMRS database.

If everything was successful, you should now have a working OpenMRS installation. Congratulations! Now you just have to install an API. If not, it's probably your fault. Just kidding. If you have any issues or comments, or something is just plain wrong, please leave a comment or email me. 

-Craig

Reflecting on Communication

Howdy

The projects are selected, groups assembled, and the course is underway. It's been several days, and I'm still having trouble building OpenMRS. My machine keeps convincing itself that it is overheating during the build, and promptly shutting itself down. Which is fine. I'm not even mad. Not mad at all. Anyways, that isn't the purpose of this post.

This is about communication.

Specifically, in this post I will provide anecdotes about a time of successful communication, and one not-so-successful.

Success

Communication was a focal point in my Database Systems course last semester. I was a member of a four-person group, working with a staff member at Berea College on a project for her department. For the most part communications went very well with our "community partner," the staff member. 

Very early on in the project, we relayed to her what materials we needed in order to begin working effectively on the project. Due to this we were able to quickly gather the necessary items and information, allowing the early stages of the process to flow very smoothly. This led to a positive experience for myself and the other members of the group.

Failure

Last semester, as a TA for the Computer Organization course, I was at one point supposed to prepare an assignment for the course. I had some difficulty in putting the materials together for the assignment, and I also assumed that I had the assistance of another TA. Due to my lack of communication with the instructor, our very own Dr. Jadud, I failed to put together anything resembling an adequate assignment. Combined with the late notice of my failure, the instructor was forced to prepare an alternative lesson for the day with less-than-reasonable time.

This failure taught me the importance of keeping a steady stream of communication, and of ironing out expectations whenever I am working on something for someone else. If I had done these things, I would have been likely to have provided the desired materials with little trouble. 

In summation,

communication plays a vital role in any collaborative work, and it is important to ensure that one communicates effectively with all of those involved. Effective communication makes a positive experience out of any project, and one should always be conscious of this.

-Craig

OpenMRS Overview Stuff

After doing a bit of exploration through the OpenMRS project, my partner David and I have compiled a guided list of useful information concerning the project. Here is a fancy-looking listing of the information (format inspired by Austin Farmer).

Purpose

The purpose of the project is to provide an open source “software platform and...reference application” that allows people with no prior programming experience to create and maintain medical records.

People

There isn’t any information about how many people are working on the project readily available on the OpenMRS site, but the GitHub repository shows 195 contributors.

Activity

The project was most active from 2011 to 2013, but it is still fairly active, currently averaging about one commit per day.

Where to Start

The first thing I would do in order to start helping would be to review the wiki to more closely familiarize myself with some aspects of the project, while looking for typographical errors in hopes of making some early contribution.

Useful Documentation

The wiki has a collection of how-to articles, as well as other collections of reference materials.

Issue Tracking

The OpenMRS website has an “Issues” tab on its horizontal menu that has all raised issues and possible bugs. There are a lot of items in the list of issues raised, where some are being worked on, some have been worked on and are waiting to be re-assessed and tested. There is also detailed information about every issue raised, what kind of issue it is and it’s priority.

Download & Installation

Downloading the product would take about 8 minutes or more depending on your internet connection, and the installation may also take about 7 minutes. Which makes it a total of 15 minutes, but it could be more depending on the internet connection and may be other factors that can hinder or slow any installation on a particular machine.

Communication

OpenMRS wiki has a Developer’s guide under which there is Developer Meeting. Developers meet periodically to discuss technical issues or any technical aspects around OpenMRS.

-Craig Warner

Post One 2: The Sequel

The journey continues, in spite of the storm.

In class on Wednesday we had a good bit of discussion about the nature of a contract for the class. This contract is to be something between the members of the groups in the class, and will provide some structure of standards for communication, interaction, and work done by the individuals. It's all very tedious and boring, but it is an important component in assessing feedback so I guess we'll talk about it. 

As we discussed some different characteristics of a "good" student/teammate/developer, there was a strong emphasis on ideas related to communication. I think that this is important, as communication tends to be one place in which groups of students frequently fall short. Specifying effective methods of communication within a group, and identifying strategies for appropriate communication is important for any group, as it provides the basis of accountability for the students within the group. The ways in which communication is handled also contributes to the nature of the group. I believe that any good contract would specify methods of communication to be used for official interactions, and what kind of language, etc. is appropriate in those interactions. 

Another idea that came up multiple times was the idea of accountability for the work done by each member in a group. No one wants to carry their group member through a course. A notion of "equal contribution" was brought up, and I think it is worth looking at. Every line of code and word of a document does not correlate to another of the same, and so it's important to factor more than volume alone when evaluating someone's work. It will be important for group members to discuss any issues they have so that progress can continue being made, perhaps expressed as part of some sort of weekly To-Do List or something similar. I think that evaluating whether or not members are contributing equal work will be best done through conversations, though, due to the nature of the work. 

All in all, I am interested to see what form the contract will take. I'm also excited to look further into OpenMRS and to see who I will be working with.

-Craig 

Post One: First Looks

Hello.

This is the first post of many to follow my journey through CSC 486, which should be an interesting one considering what I have gathered about the course during the first week of classes. The course is titled Software Engineering, and in it we will be attempting to contribute to some Open Source projects while exploring the FOSS culture. I am looking forward to the class, as I feel that it will cover a lot of valuable material and provide semi-structured exploration into facets of industry that no other course in the Computer Science program are able to.

Dr. Jadud suggested several projects for the class to consider for the course. I think that they are all interesting, and I would be willing to work on any of them. However, if I had to determine the most and least interesting projects to me out of the list, I would have to choose OpenMRS and OctoPrint, respectively. 

I think that the mission of the OpenMRS project is admirable and just awesome, and I think much of the class likely shares my interest in the opportunity to try and help something that will help so many people. To take a step in the other direction, I am not personally very interested in the OctoPrint project because I'm not very interested in 3D-printing myself. I think that 3D-printing has, is, and will continue to revolutionize the world, and it's really cool, but I don't see myself being very involved with it.

At any rate, I'm sure that this will be a course to remember. I anticipate blank stares, zombie-like groans, stress, conversation, and all sorts of hi-jinks, and I'm eager to get started.



-Craig Warner