Chen's Ph.D. Weekly

Spent a very CRAZY day in NYC. Couldn't get back to Jersey city because the PATH stopped running due to a fire in 33rd street. Experienced a late night visit to Newark, which was brave.

Refreshed my memory of assembly language

Getting to learn the good part (meta programming and list pattern matching) of OCaml

Read an article about how to make an NMOS at home, found the hardest part is to deal with Hydrofluoric acid.

Had some reading about FGMOS, which is the key component of gate based storage.

In the MVC structure of a system, I think we can see model as mechanism, controller as the implementation of policy, view as interface

Read the paper Virtual Memory, Processes,and Sharing in MULTICS by Robert C. Daley & Jack B. Dennis, the idea of hot-change of hardware and generalized address space is awesome.

Spent a whole day diving into OCaml, still felt its syntax is way too unnecessarily ugly and weird.

Dealt with a lot of school things.

Had some reading and practice on OCaml, pretty impressed by its pattern match and static strong type features. Even though at first I thought its syntax is pretty weird, now I think it's very worthy of digging in. Maybe some of its features can make it a good candidate of next generation of law language. Its match feature and functional programming feature is interesting, but it may bring some difficulty in dealing with complex data structures.

Started reading the book Real World OCaml by Yaron Minsky, Anil Madhavapeddy and Jason Hickey.

Added MathJax support in this site. Now we can have things like this: $$\oint_{\partial \Sigma} \mathbf{B} \cdot \mathrm{d}\boldsymbol{\ell} = \mu_0 \iint_{\Sigma} \mathbf{J} \cdot \mathrm{d}\mathbf{S} + \mu_0 \varepsilon_0 \frac{d}{dt} \iint_{\Sigma} \mathbf{E} \cdot \mathrm{d}\mathbf{S}$$ Maybe one day we can replace LaTeX with Markdown + MathJax, which can make life much easier...

Read the UNIX paper The UNIX Time-Sharing System by Dennis M. Ritchie and Ken Thompson

Got a better understanding of the difference between trap and interrupt in OS. Interrupt is in fetch phase (for any instructions), while trap is in decode phase (for specific instructions).

"Every Unix command eventually become an internet service. Grep->Google, rsync->Dropbox, man->stack overflow, cron->ifttt ... etc" - @cdixon

The OIT was very interested in Git, so I helped them install GitLab for code management based on Git. Also wrote a script to replace the ugly fox logo of GitLab with any other pictures for the Omnibus GitLab installer.

Made a comprehensive document for OOI CI's database mechanism for digesting raw data.

Successfully ran some Javascript code inside a Java class with Rhino, and achieved object sharing between the Javascript code and the Java class. This means we can operate on LGI control states with the embedded javascript. Since javascript is specially convenient in dealing with nested list and key-value pairs because of JSON, this will bring us much benefit in writing LGI laws. I'm planning to build an engine for Moses to support javascript laws by the end of Spring semester of 2015.

I think Javascript law, ZeroMQ interface and hierarchical law support can be three most interesting features of the next version of Moses.

Started reading The Art of Unix Programming by Eric S. Raymond. Even though I've already read its Chinese version, I think it's necessary to read its original version from the start.

Got some rudimentary understanding of OOI CI's mechanism to digest raw geo data, most of which is of the aspect of database.

Compiled some javascript code into Java byte code with Rhino and successfully ran it in JVM. The next step is to run embedded javascript, say, load a javascript code from a text file into a Java class and execute it, it will be best if we can make object sharing between the embedded javascript code and the Java class.

Had some research on Apple's Safari browser's plugin mechanism. Transplanted some of my favorite greasemonkey userscripts into Safari.

Got proficient in playing "La fille aux cheveux de lin". Started "Clair de lune". Plan to get proficient by the end of the new semester.

Finished the installation script. Got a new mission of finding out the mechanism of how OOI CI processes raw geo data from the ocean sensors.

Had some research on HDF and NetCDF, refreshed my memory of Hadoop and dynamic programming.

Had a trip to Washington D.C. The most impressive things are the Impressionism collection of National Gallery of Art, and the blue crabs in Baltimore.

Had some research on PostgreSQL. Its JSON-based query feature is very interesting, but I need some benchmark data to say it's efficient enough for production. If so, it will bring much impact on database design.

Had some research on ZeroMQ. Maybe we can use ZeroMQ to make a efficient language-independent interface for next generation of Moses, instead of making APIs for every language.

Learned sed in detail because I need to use it to change some config files in my installation script of OOI CI.

Finished most of the installation script.

Finished most of the installation guide of OOI CI. Started writing the script.

Found a decent "minimum" linux distribution called CoreOS, and its design purpose is very much like what I expected.

Found a PaaS system called Deis, and a pretty decent project called Docker for shipping software within a thin virtual machine layer.

Found a good project called Vagrant which is a unified interface of many virtual machine managers, such as Virtual Box. I wrote a command called mkvm that can fast generate a virtual machine running a minimum OS, this can let me make crazy experiments without breaking anything in my main system.

Found a good project caked Serf which somehow shares some ideas with the implement of Moses.

Started reading Pointers on C by Kenneth Reek, which I found in the lab.

Got a chance to take part in the project OOI CI (Ocean Observatories Initiative Cyberinfrastructure). This is big project for ocean research, basically it's a giant distributed system consists of ocean sensors on Yellow gliders across Atlantic and Pacific Ocean.

The installation of this system is tedious and complex, and there wasn't a complete manual. My first job was to figure out a good installation guide for it and make it running on a Debian box. My final plan was to build an automatic installation script for it. I figured out part of the installation of dependencies.

Started some research on lightweight system virtual machines. I was trying to build (or find) a minimum Linux system that costs very small amount of resource, but is able to support programs running. This can make it possible to bring benefits of virtual machines (easy deployment with appliance, easy maintainability with snapshots, environment isolation, etc.) without much overhead.

Stopped the research of PDF format because I found an open-source engine for the purpose. Finished the invoice generator with this open-source engine, and finished the task log project.

Started the research on Rhino. It's a Javascript engine running on JVM, I realized it would be very useful for my plan of supporting LGI laws in Javascript in Moses.

Finished most of the task log system, did some research on PDF format, the final goal was to build an engine to generate PDF file with HTML and CSS. This was for the component of dynamic invoice generation.

Refreshed my memory of Aristotelian logic by reading Logic: The Art of Defining and Reasoning

Finished building a lightweight PHP web framework (less than 30k), and started to use it to build a task log system for Rutgers OIT.

Started reading the book Logic: The Art of Defining and Reasoning by John A. Oesterle.