"

From 2011.igem.org

Contents 1 Life = 42 2 To-Do List 2.1 PuppetShow Thought Project 2.2 BU Wellesley Collaborative Meeting #1 3 The Day-to-Day 3.1 [6/8/2011] 3.2 [6/9/2011] 3.3 [6/10/2011] 3.4 [6/13/2011] 3.5 [6/14/2011] 3.6 [6/15/2011] 3.7 [6/16/2011] 3.8 [6/17/2011] 4 The Backburner 4.1 Protocol Graphs Thought Project 5 The Guestbook

Life = 42

jtferns

My HTML scratchpad

--Jtferns 15:47, 7 June 2011 (CDT)

To-Do List

• read through Doug's Algorithm paper [http://www.ncbi.nlm.nih.gov/pmc/articles/PMC2860133/]
• read through AssemblyManager code
• read through ClothoHelp [http://wiki.bu.edu/ece-clotho/index.php/Main_Page]
  • edit main page to allow for click-able images
  • break main page
  • fix link-caption centering issue
• read through kirigami/TB paper
• read through Friedland abstract/paper [6/7/2011]
• implement HTML in the wiki
• create a sandbox/html-testing page
• create a fully-functional interactive calendar
  • create a basic calendar
• create a fully-functional navigation menu/bar
• create an HTML notebook page
• win the wiki War

PuppetShow Thought Project

• read through Puppeteer/PuppetShow powerpoint [6/7/2011]
  • PuppetShow takes some version of the protocol graph produced via the Assembly Planner
    • The relationships between parts within the protocol graphs are assumed to be labeled with protocol names
    • The PuppetShow itself should link the protocol names to libraries and help generate the necessary Puppeteer code
• read through Puppeteer/related abstract [6/7/2011]

Using the Clotho platform [4], we develop two
applications for specifying and executing biological protocols.
The Assembly Planner [5] is the end-point of an endto-
end design workflow [3] that produces an assembly plan
for synthetic biological devices, with each assembly step
annotated with the name of a biological protocol. Each
such protocol itself may be fully specified using another
Clotho application called PuppetShow, which provides an
environment for writing, testing, debugging, and executing
biological protocols.
--A Software Stack for Specification and Robotic Execution of Protocols for Synthetic Biological Engineering

• peruse GroovyScripter code/structure
  • read up on JEditorPane first!! [6/8/2011]
    • need to find out how to properly import Python shell to run Python code [6/9/2011]
    • able to successfully incorporate python interpreting using native Python 3.2 installation!
  • attempt to mimic GUI and incorporate Python-parsing? [6/8/2011], [6/9/2011]
    • able to successfully mimic the JEditorPane!!
• figure out how to seamlessly integrate Python script-compiling within fluid GUI [6/9/2011]
• design aforementioned fluid GUI
  • currently working on implementing fluid menu bar design for easy navigation and script creation/manipulation [6/10/2011]
• need to meet with Viktor and Chenkai to discuss the integration of the Puppeteer stack components into PuppetShow
  • add button and feature allowing the user to import collections from the database (much like how Algorithm Manager imports collections) [6/16/2011]
  • add couple more buttons with specified features (TBD)
    • dropdown selections to represent different possible tree annotations (non-functioning for now; defaults to BioBrick)
    • tabbed panes (still working out several kinks)
    • generate-Puppeteer button (eventually will function off of dropdown selection)
• comment most, if not all, of the PuppetShow code [6/17/2011]

BU Wellesley Collaborative Meeting #1

1. Give a summary of what I am doing
   • I am currently working on the development of a tool called PuppetShow. Initially, it was designed to be a simple Python-editing tool that would assist those working with Puppeteer scripts (which are produced through Python scripts). Since then, it has evolved into a tool that combines several features into one application. For now, it allows the user to freely create/open/save Python scripts and execute them with the appropriate output and error streams. It also allows the user to import a database or local collection, with which they can generate Puppeteer code using Chenkai's Puppeteer-generating code.
2. Explain how it fits into the overall iGEM project
   • PuppetShow fits into the overall iGEM project as a versatile tool that will eventually allow knowledgeable users to create custom protocols for wetlab purposes. This should facilitate the usage of the Tecan robot, which should help the wetlab team increase their efficiency and decrease their sources of error.
3. Explain what my next steps (up to a month) are and my timeline for carrying these out
   • I will merge my to-do list with my expected steps in some nice format soon. Until then, my timeline involves:
     • Fix tabbed pane issues by this Friday (6/24)
     • Finalize/implement annotation selector by next Friday (7/1)
     • Use gathered details to optimize test mode and look into simulator requirements by Friday (7/8)
     • Hopefully optimize/clean up any additional features and have PuppetShow polished/presentable by Friday (7/15)
4. Let everyone know anything I don't understand, anything stopping my progress, any equipment/resources I need, etc
   • CIDAR couch?
   • CIDAR microwave Thanks Evan!

The Day-to-Day

[6/8/2011]

Finally got the plugin to properly load off of the Clotho dashboard. It runs as a JEditorPane with (I assume; has yet to be verified) Python-syntax-highlighting. Next up is finding a way to properly integrate a "run" method for parsing/executing Python scripts made within this GUI.

Got a bare-bones menu-bar working. It doesn't have any functioning implementations, yet. However I'm going to stop here until I can figure out how to parse Python and run it from the GUI window.

[6/9/2011]

I started looking into incorporating the Jython library/software package to assist with compiling Python scripts, etc. However, as per Swapnil's advice, instead I shifted to just trying to run the Python scripts directly off of a native Python installation. This makes sense since one would currently need to have Python installed to work with Puppeteer, so executing/compiling the Python scripts/code should work.

Right now I am trying to properly code the runtime-execution of python to parse some sample code within a test file that I placed within the App directory. My thoughts for future development involves saving the written code to a temp file and executing the code when the user chooses the run command.

Update: The App can now fully parse text written within the custom-JEditorPane and interpret it using the native Python 3.2 installation. I have currently abandoned any interest in incorporating Jython and will focus more on GUI design and simple file-manipulation.

[6/10/2011]

The cloning process is complete. The PS Scripter can now fully open files, save them, save them as a new file, and run the script. I will continue to play around with more GUI options but I will be leaving this App/Module alone so I don't brick anything just yet. The next step involves creating some new App with a more streamlines GUI that has some kind of status window.

Update: GUI now has a neat status window. I am currently implementing this by appending Strings to the TextArea, but there might be a better setup for future development. Right now it only spits out the basic text that I relied on for debugging. Eventually, it would either incorporate the python output/error stream (if possible). It also has a non-functional progress bar that I threw in for fun; if I can't get it to work with compile/run-time progress I will replace it with a status text.

[6/13/2011]

The GUI has been re-designed to contain a re-sizable bar to vary the height of the visible JEditorPane and JTextArea; these are the python-scripting area and status window area, respectively. The status window itself now features descriptive text (need to fix some alignment issues) and the direct output and error streams from the python-script-execution. The image to the right shows the new GUI as well as some example code and the resultant status window text.

[6/14/2011]

Fully re-designed the menu-bar components such that they were easily-modified via the built-in Netbeans GUI development tools. This resulted in the newly-implemented hotkeys for the various menu-bar components. Additionally, a new feature was added: custom command input. This feature allows the user to input a custom command for the runtime process execution; this allows users to input custom flags/commands as needed to do more with their Python scripts. Unfortunately, the current setup relies on saving the code opened/typed into the PS window to a "testing.py" file, which is what the Python interpreter compiles by default.

Update: The runtime process now no longer relies solely on the "testing.py" for executing previously-saved code. Instead, it uses the selected file once the user opens/saves their work. This change is also accurately reflected within the custom command option, which either presents the default "testing.py" choice or the current file appended to the default run-command text.

An issue that I still cannot figure out concerns why Swapnil cannot see the Python syntax-highlighting on his machine. My machine as well as the CIDAR PC1 both detect and highlight the code accurately. Therefore, something within the JSyntaxPane is acting up on Swapnil's machine. Currently the module is set up to use the associated JSyntaxPane library, so I might try experimenting with just wrapping the most recent JAR instead.

[6/15/2011]

I was working on my HTML scratchpad until Viktor, Chenkai, and myself had our meeting regarding the design of PuppetShow.

For now, I am to focus on implementing a feature that allows the user to import collections from their database connection. I was told that AlgorithmManager already supports this, so that app will help with the proper integration techniques as well as help me familiarize myself with the Clotho API. I am currently re-designing the GUI to provide easy-integration for several features that we have discussed and will be providing more information later on.

[6/16/2011]

PuppetShow now has a functioning (needs some error-debugging) import button that allows the user to import a collection from their current database connection. Some more functionality will be added in the future, but for now I will work on some code-beautification techniques.

[6/17/2011]

Currently finishing up my effort to comment most of the PuppetShow code.

Update: Several new features were added. Chenkai's Puppeteer-generator code was implemented into PuppetShow, as well as a tabbed-view feature. A lot of it is still being tested so there are a couple visual glitches. For the most part collections can be imported and used to generate their own Puppeteer code.

The Backburner

Protocol Graphs Thought Project

• Ideally, we should have a protocol graph that would be a generic form of managing an arbitrary combination of protocols.
• The protocol graph should contain vertices, which are either operands or protocols/operations.
• The graph should also connect operands to protocols.
• Given access to a library of protocol specifications, one should be able to give an expression or an explicit protocol graph for parsing purposes.
• One should be able to use PuppetShow (see powerpoint) to create an implicit protocol graph.
• One should be able to reconfigure protocol graphs for optimization, etc.
• Questions
  1. How do we want to construct this graph?
  2. Does the user input an expression?
  3. Should we have an interactive GUI to help user create custom protocol graphs?

The Guestbook

Feel free to leave (appropriate) comments, suggestions, questions, notes, etc., here: