One particular trait that I personally like in VS is, tracking the code changes in the editor (with small green and yellow bars appearing on the side for changed and saved code portions). If you are like me, then you are probably using Linux VMs (on Windows) to build and test Meteor Projects. Here is one simple way to smooth the workflow.

1. Get Node.js Turnkey Linux VM: https://www.turnkeylinux.org/nodejs
2. Launch your Linux VM with Virtual Box
3. Setup your Meteor project (with meteor add command or git clone command)
4. Test if you are able to connect to your Linux VM through ftp. If not, you may want to install vsftpd. Refer: https://www.wikihow.com/Set-up-an-FTP-Server-in-Ubuntu-Linux
5. Launch Visual Studio 
6. Select the Open | Website option from File Menu.
7. Enter your FTP details. You can leave the Directory option empty, which will let you browse the whole Linux user home directory from VS. Else you can specify the meteor project directory
8. Once the solution is opened successfully, right click on the ftp project in the solution explorer and choose Browse With ... option.
9. In the browse with dialog, enter the url of the meteory project. Typically you just need to add port (:3000) to the end of the url.
10. Once done, you can press Ctrl + Shift + W to launch your meteor project in default browser. Else use the context menu option View in Browser.

At the end of that case study video I promised to demonstrate computing failure rate when you have no access to sensor data, purely from historic maintenance failure records.

Here is the video that demonstrates predicting future failures from historic failure data.

With this analysis, you can answer questions such as:

• How many failure are likely to occur by the end of next year?
• If I were to choose between two types of design, which one is more likely to meet my reliability requirements?
• What is best inspection cycle that I should employ? etc...

For more details on predictive analytics and its application in relation with M2M big data Telematics and Natural language processing for health care applications, retail and automotive, refer to my publications, available at: https://gopalakrishna.palem.in/Publications.html.

• Corrective Maintenance
• Preventive Maintenance
• Predictive Maintenance

Corrective maintenance is the classic Run-to-Failure reactive maintenance that has no special maintenance plan in place. The machine is assumed to be fit unless proven otherwise.

• Cons:
  • High risk of collateral damage and secondary failure
  • High production downtime
  • Overtime labor and high cost of spare parts
• Pros:
  • Machines are not over-maintained
  • No overhead of condition monitoring or planning costs

Preventive maintenance (PM) is the popular periodic maintenance strategy that is actively employed by all manufacturers and operators in the industry today. An optimal breakdown window is pre-calculated (at the time of component design or installation, based on a wide range of models describing the degradation process of equipment, cost structure and admissible maintenance etc.), and a preventive maintenance schedule is laid out. Maintenance is carried-out on those periodic intervals, assuming that the machine is going to break otherwise.

• Cons:
  • Calendar-based maintenance: Machines are repaired when there are no faults
  • There will still be unscheduled breakdowns
• Pros:
  • Fewer catastrophic failures and lesser collateral damage
  • Greater control over spare-parts and inventory
  • Maintenance is performed in controlled manner, with a rough estimate of costs well-known ahead of time

Predictive Maintenance (PdM) is an alternative to the above two that employs predictive analytics over real-time data collected (streamed) from parts of the machine to a centralized processor that detects variations in the functional parameters and detects anomalies that can potentially lead to breakdowns. The real-time nature of the analytics helps identify the functional breakdowns long before they happen but soon after their potential cause arises.

• Pros:
  • Unexpected breakdown is reduced or even completely eliminated
  • Parts are ordered when needed and maintenance performed when convenient
  • Equipment life and there by its utilization is maximized
• Cons:
  • Investment costs for implementing the condition-based monitoring (CBM) system
  • Additional skills might be required to effectively use the CBM system effectively

Predictive maintenance, also known as Condition Based Maintenance (CBM) differs from preventive maintenance by basing maintenance need on the actual condition of the machine rather than on some preset schedule or assumptions.

For example, a typical preventive maintenance strategy demands automobile operators to change the engine oil after every 3,000 to 5,000 Miles traveled. No concern is given to the actual condition of vehicle or performance capability of the oil. If on the other hand, the operator has some way of knowing or somehow measuring the actual condition of the vehicle and the oil lubrication properties, he/she gains the potential to extend the vehicle usage and postpone oil change until the vehicle has traveled 10,000 Miles, or perhaps pre-pone the oil change in case of any abnormality.

Predictive analytics with M2M telematics provides such deep insights into the machine operations and full functionality status – giving rise to optimal maintenance schedules with improved machine availability.

The enormous data streamed in realtime from sensors attached to the machine/vechile is processed with big data architectures to enable anamoly detection and failure prediction in real time.

The demo video above showcases the Predictive Maintenance in operation. It demonstrates computing the Failure rate and MTTF from realtime operating conditions of machine.

More details can be found in my M2M Telematics & Predictive Analytics paper.

However, you can survive past those initial hurdles with few adjustments in the preferences. In the below I list few common challenges that Maya users face with Blender and how to circumvent them, if not eliminate them completely.

• Right Mouse Button Selection:This one is the source of all evil. This is what happens if you do not follow the well-established usage conventions and software UI behavioral patterns.

  Luckily the adamantium got depleted at Blender camp and now, as of version 2.68, they ship Maya Preset bundled by default that works flawlessly in mimicking the native Maya selection behavior. Select it from the File|User Preferences menu option, then the Input tab and Presets dropdown box.

• Scale, Rotate, Move: You can use your E, R, T usual shortcuts for these, using the Maya Presetconfiguration.
  
  
• Viewport Shading mode: Again, the Maya preset takes care of this one nicely. Press 4, 5 and 6 keys as you would have in Maya and now your viewport makes the meshes appropriately.
  
  
• Perspective / Ortho views:Well, for this one, the Blender native shortcuts are, NumPad-0 through Numpad-7. Not an ergonomic choice, given that NumPad keys are half way across the globe in the eastern side of keyboard (which is not your keyboard hand's natural resting position), and also most laptops do not have NumPad keys (know your customers: open-source 3D modeling software customers more likely to be trying Blender on laptops for a quick peek rather than a dedicated professional setup in their initial stages).

  But luckily, you can now use Ctrl+0 through Ctrl+7 shortcuts for the same effect. No need for NumPad keys. Agreed, Ctrl+0 is not same as NumPad-0 (two keys vs one key) but atleast you have a way out. (There are some scripts also in the Blender Add-ons that might be able to help you with this one.)

• Camera Navigation: Perhaps, the most irritating feature (or, shall I say bug) that you encounter in Blender (coming from Maya) is, once you are in Camera perspective (Ctrl+0 short-cut, same as 'look through camera' feature of Maya) if you try to adjust its positioning by transformation or rotation, the view goes out of camera perspective. There is just no way you could adjust your camera while looking through it. You would have to use two views, one to look through the camera, and the other to adjust the camera like a normal 3D-object. Yuck.

  Luckily, at least in latest build 2.68 of Blender, you have a way out of this. Actually not one, but two ways. First is, press Shift+F within camera perspective (with the camera border selected), you enter a Fly mode. Then you can position the camera by using mouse-wheel and buttons.

  But I have a more better option. With the camera selected, go to its View properties, and select Lock Camera to View check box. Once ticked, then you can just use your regular Pan, Zoom etc. keys to adjust the scene and your Camera indeed gets adjusted. Once you are done, you can uncheck it and get along with your model as usual.

By the way, it is not for nothing that companies like Apple or Microsoft spends millions of dollors in conducting detailed UI behavioral profiling studies, time and again proving: "Being creative is pefectly possible without voilating conventions". Though who or what defines convention is upto each individual to decide for oneself.

However, the solution did not come straight, but it just occurred to me while I was working on something else entirely different.

Here I was, preparing my Healthcare Analytics white paper working on its Title page from scratch, and the realization dawned upon me - if you are a Latex user like me, then you have all the necessary tools at your disposal to perform the tricks on PDF files - once you become aware of this small package called pdfpages, that is. You can quickly, in just a single line or two, do whatever you want with your scanned PDF documents all by your own Latex code.

The includepdf command is going to be your solution. For example, the below code lets you extract 3rd page from your scanned PDF file:

\documentclass{article} 
\usepackage{pdfpages}

\begin{document}
\includepdf[pages=3]{scanned_Doc.pdf}
\end{document}

Now, you might encounter online tools to merge few PDF documents into a single document, but they may not let you selectively pick pages from each of those documents and then do the merge. This kind of merge is pretty straight forward with includepdf as shown below.

Here is how you can combine pages from your cover letter PDF document with selective pages from your scanned certificate documents:

\documentclass{article} 
\usepackage{pdfpages}

\begin{document}
\includepdf[pages=1]{CoverLetter.pdf}
\includepdf[pages={3,4}]{cert.pdf}
\end{document}

The package also lets you insert multiple extracted pages in a single page with nup option, as below (where first 1 to 4 pages are arranged in 3 columns x 2 rows on a single page):

\includepdf[nup=3x2, pages=1-4]{cert.pdf}

You should be able to offset the extracted PDF into correct location on your page using the regular setlength commands. For a full page PDF insertion, you can try something like below:

\documentclass{article} 
\usepackage{pdfpages}
\pagestyle{plain} % no page numbers
\begin{document}
\setlength\voffset{-0.1in} % adjust the vertical offset
\setlength\hoffset{-0.4in} % adjust the horizontal offset
\includepdf[pages={2,2,2}]{Scanned_Doc.pdf} % insert 2nd page from Scanned_Doc three times
\end{document}

For further details on how to add overlays or annotations to the PDF pages, visit my article: PDF Page Manipulation.

SSL related errors look like below:

/sector/common/ssltransport.cpp:229: undefined reference to `SSL_new'
/sector/common/ssltransport.cpp:230: undefined reference to `SSL_set_fd'
/sector/common/ssltransport.cpp:232: undefined reference to `SSL_connect'
/sector/common/ssltransport.cpp:234: undefined reference to `SSL_free'
/sector/common/ssltransport.cpp:239: undefined reference to `SSL_get_verify_result'

The way to solve them is:

• For the ::close() error in the tcpTransport.cpp, prefix UDT as explicit namespace and it will be good. It should read, UDT::close(m_iSocket)
• For the usleep errors, these happen in multiple locations in the source, and you want to add #include <unistd.h> in respective files to resolve it (there will be many, so you have to keep issuing make and correct them one by one)
• For the SSL related errors, first ensure you have SSL development files installed (e.g., libssl-dev for Debian or openssl-devel for Fedora). You can check with ldd $(which openssl)
• The main problem that happens in Sector make files for SSL is, out of order library linkage. The ssl, crypto libraries should come after libclient.a and libsecurity.a on the g++ command line, but the make files have it incorrect. Need to correct this.
• You can correct the make files (one by one, once again) by opening the respective make file that is causing the error from the corresponding directory and adding -lssl -lcrypto to the end for LDFLAGS variable. It should look something like:

  LDFLAGS += ../lib/libclient.a ../lib/libsecurity.a ../lib/librpc.a ../lib/libcommon.a ../lib/libudt.a -lssl -lcrypto

GePhi has interesting visualization capabilities built around graphs - and igraph is one of the widely used graph processing libraries for R. But there is no straightway to combine these two at present in R. The gexf format used by GePhi is not currently supported by the igraph package.

GePhi has its own package, the rgexf package for R, that provides some support for creating GePhi styled graphs out of custom matrix/dataframe data. It would have been great if it accepted an igraph object straight out-of-the box and generated a gexf object from it. But the current version does not support it. However, rolling out your own exporter is not that difficult. Here is something to get you started.

  # load the igraph and rgexf packages
  library(igraph)
  library(rgexf)

  # create a sample igraph object
  cg1 <- erdos.renyi.game(10, 0.8)

  # construct the nodes and edges data for gexf conversion
  nodes <- data.frame(cbind(V(cg1), as.character(V(cg1))))
  edges <- t(Vectorize(get.edge, vectorize.args='id')(cg1, 1:ecount(cg1)))

  # do the conversion
  write.gexf(nodes, edges)    

This piece of code will generate xml formatted in gexf ready for GePhi. You can further add node attributes and edge weights in similar fashion.

There are couple of points to be taken care though, such as xml & problem. For some reason, write.gexf fails to properly handle & symbols in the attribute vectors, so you would have to convert the & symbol to & before sending it to write.gexf.

Also note that write.gexf writes to console output and does not save to file. You would have to use print method for that. This is somewhat confusing naming convension !!

A reusable method with complete source code for exporting the igraph nodes and edges along with the associated attribute data can be found here.

For example, consider the below function that accepts two numbers and returns some computed value based on them.

    getNc2 = function(vc, ec)
    {
      # compute nC2 and return the ratio
      max_ec = vc * (vc-1) / 2
      return (trunc(ec * 100 / max_ec))
    }    

This is a valid function in R, and perhaps similar to any C++ or Java method, except it works on both single number input and vector inputs. For example, note the below single number input calls:

> getNc2(5, 4)
[1] 40

> getNc2(6, 5)
[1] 33    

Now, those two calls can be combined into a single vector call as below and our above definition works perfectly fine without complaints:

    > getNc2(c(5,6), c(4,5))
    [1] 40 33    

The method accepted two vectors (instead of just two individual numbers) and returned vectorized results. Something not quite natural in C++ or Java, unless special care is taken to define the argument types as templated parameters and so on.

Now, what about the limits? Our method is computing a ratio which essentially involves a division. If we are not careful, we can endup with dividing-by-zero. For example, consider the below calls:

> getNc2(0, 5)
[1] -Inf

> getNc2(0, 0)
[1] NaN    

Suppose, we want to handle these cases where the argument is zero and return 0 instead of -Inf or NaN. Then we will be adding an if condition as below:

    getNc2 = function(vc, ec)
    {
      # if no vertices return 0
      if(vc <= 1) return (0)
      # compute nC2 and return the ratio
      max_ec = vc * (vc-1) / 2
      return (trunc(ec * 100 / max_ec))
    }    

Now, the earlier calls will return 0 correctly as shown below:

> getNc2(0, 0)
[1] 0
> getNc2(0, 5)
[1] 0    

However, the if condition introduces a new problem. if in R is not a vector-compatible opration. It works only for scalar inputs and as such our method hence fails on vector inputs. For example:

> getNc2(c(5,0), c(4,5))
[1]   40 -Inf
Warning message:
In if (vc <= 1) return(0) :
  the condition has length > 1 and only the first element will be used    

Now, there are couple of ways you can address this problem. One would be to use apply constructs - but they can be overkill oftentimes. Other way is, using ifelse instead of if etc. vector-capable operations explicitly. That would work, provided you have the option to change the source. What about cases where you are using a method from some package and you cannot change the method ?

Take the method get.edge from igraph package, for example. It accepts an edge id and returns the vertices for that edge. However, if you supply a vector of edge ids, it will not work - it just returns the vertices for only the first edge, as can be seen from the below output:

> cg <- erdos.renyi.game(8, 0.6)
> get.edge(cg, 13)
[1] 4 6
> get.edge(cg, c(13,15,16))
[1] 4 6    

How do you make these kind of methods work for vector inputs as well as scalar inputs? R has a nice base method under its sleeve that exactly addresses this problem. Named Vectorize, it helps in these situations - coverting scalar methods to vector methods.

Vectorize creates a function wrapper that vectorizes the action of its argument function. For example, we can vectorize our getNc2 method as shown below:

> Vectorize(getNc2)(c(5,0), c(4,5))
[1] 40  0    

Instead of directly calling getNc2, we are rather creating a wrapper around it by calling Vectorize method with getNc2 as its argument, and supplying the original vector inputs to the resultant function. In other words, the above is same as:

> vecNc2 <- Vectorize(getNc2)
> vecNc2(c(5,0), c(4,5))
[1] 40  0    

Remember, the vectorized vecNc2 method works perfectly fine on scalar inputs too. For example:

> vecNc2(5, 4)
[1] 40    

By default Vectorize tries to vectorize all the arguments of the supplied method, which may not work sometimes. For example, the earlier example of get.edge in igraph:

> vecGE <- Vectorize(get.edge)
> vecGE(cg, c(13,15,16))
Error in function (graph, id)  : Not a graph object    

Here the get.edge method is accepting two inputs, one the graph object itself and the second the edge id - and we want to vectorize only the second argument, namely the id argument and not the graph object. For this, we would have to use the vectorize.args facility of Vectorize method as shown below:

> vecGE <- Vectorize(get.edge, vectorize.args="id")
> vecGE(cg, c(13,15,16))
     [,1] [,2] [,3]
[1,]    4    1    2
[2,]    6    7    7    

This is a simplified output of the Vectorize method. We can use the SIMPLIFY facility of Vectorize method to get the original results unaltered. For example:

> vecGE <- Vectorize(get.edge, vectorize.args="id", SIMPLIFY=FALSE)
> vecGE(cg, c(13,15,16))
[[1]]
[1] 4 6

[[2]]
[1] 1 7

[[3]]
[1] 2 7    

Note, this is same as the lapply output.

> lapply(c(13,15,16), function(id) get.edge(cg, id))
[[1]]
[1] 4 6

[[2]]
[1] 1 7

[[3]]
[1] 2 7    

So go ahead and use Vectorize whenever you want to avoid lapply constructs for methods that accept only scalar inputs.

First, you need to get the dependencies (ZeroMQ library and MikTex) ready. ZeroMQ, as usual, can be downloaded from here, and MikTex from here. In case you opt for MikTex portable, you might need to add the MikTex bin path to the system path (i.e. pdflatex.exeprogram from the MikTex bin directory should be accessible at the command prompt). In case you are on a 64-bit machine, then you might need to install both 32-bit and 64-bit versions of the ZeroMQ libraries to ensure your package build succeeds. By default, the R build command tries to build for all platforms.

Also, you would need to download the zmq.hpp file (from here) and put it in the ZeroMQ include directory. Otherwise, you will get compiler error.

Very importantly you would need the RTools to build R packages from source. Get the RTools from here. Ensure you select the path adjustments recommended by the installer. It is VERY important that the RTools bin directory comes before the rest of your path. Otherwise there is a good chance that you will never get it to work.

After setting the dependencies, get the latest rzmq source from git here (the one on CRAN is very old - do not use it, use the git version directly) and extract it to some directory on your disk. Lets say you extract it to C:\, then you have C:\rzmq\src\interface.cpp file that need to be compiled.

• First, open your Visual Studio command prompt and go to your extraction folder where rzmq folder is present. In our example it is C:\
• Now if you issue the command R CMD check rzmq you should see some output, and perhaps some build error.
  • If you get "Warning: 'rzmq' is neither a file nor directory, skipping" error, then you are not in the right directory. Go to correct directory that has rzmq folder inside it and issue the command again
  • R commands are case-sensitive, so ensure you type CMD check exactly as is
  • If you get unknown command or invalid command error, ensure that your R installation is accessible from command line. You might want to add your R bin path to your system path.
• Build error might happen due to ZeroMQ libraries not being found. This can be fixed by modifying the Makevars file in the rzmq/src folder. The Makevars file lets you supply the additional include paths, library paths and library files required for building the C++ programs as R package. You need to set the PKG_LIBS and PKG_CPPFLAGSvariables correctly. Typically it should read,
  • PKG_LIBS = -L"C:\Program Files\ZeroMQ 2.2.0\lib" -llibzmq-v100-mt
  • PKG_CPPFLAGS=-I"C:\Program Files\ZeroMQ 2.2.0\include"
  You should specify your ZeroMq library path and header-file locations as above. The libzmq-v100-mt is the .lib file that is present in the C:\Program Files\ZeroMQ 2.2.0\lib. Note the -l before the libzmq-v100-mt.
• Now you need to copy all dll files from ZeroMQ bin directory to to the rzmq/srcfolder.
  • For example, copy C:\Program Files\ZeroMQ 2.2.0\bin\*.dll c:\rzmq\src\
• Issue the command R CMD check rzmq again. It should complete fine.
  • You might have to add the pdfLatex.exe path to your system path
  • Your MikTex distribution might be missing couple of packages and you might be prompted for installing them.
• If everything is completed successfully, you should have a rzmq.RCheck folder alongside your rzmq folder with rzmq-manual.pdf built inside it correctly.
• Now use the command R CMD INSTALL rzmq to install the built R package to your R libraries repository.
  • You can use the --library option with the R CMD INSTALL to specify an alternate R library location, if required

You should now be ready to use rzmq from your R.

On 64-bit machines, instead of the above indicated, you want to use the below --no-multiarch version commands:

    R --arch x64 CMD check --no-multiarch rzmq

    R --arch x64 CMD INSTALL --no-multiarch rzmq

Consider the case where you have a QLineEdit object with editingFinished() handler, along with a QPushButton with its relevant clicked() handler (or a toolbar /menu action with its triggered() handler). Now try typing something in the lineEdit followed immediately by a click on the button or menu/toolbar (while the cursor is still in the text box). You will see the button clicked() (or toolbar action triggered()) handler getting invoked before editingFinished() handler.

This happens because of the incorrect order in which focus out and button clicked events are raised by Qt. For some reasons, when focus shifts from textbox to button, the clicked() event for button gets triggered before the focusoutevent() for the lineEdit.

Now, if you do not see this behavior, then you do not need to worry. On the otherhand, if you do see this behavior, but argue that its a feature - good luck to you - but for my CarMusTy, this out of sequence event order means a problem, since there are custom property managers user has to deal with and receiving editingFinished() after the button event handler means having inconsistent state in the generated pdf. (In case you are wondering what CarMusTy is, its a Typesetting environment for editing and publishing high quality Carnatic Music Books. Compromising on quality is certainly not an option for this application.)

Now, how do we deal with such situation - is there a way you can force the event order in the Qt. Something that can help you tell Qt to raise the editingFinished() of lineEdit before the clicked() handler of button?

Luckily, there is one. Here is the way CarMusTy addressed this problem. Try this - it might help you too.

The event subscription mechanism of Qt allows you to specify how the handler should be invoked, through Qt::DirectConnection and Qt::QueuedConnection options. The Qt::DirectConnection lets the handler be called right-on-the-spot when the signal is emitted vs. the Qt::QueuedConnection lets the handler be pushed into the event queue and called next time when the event loop is executed. Combine this with the QCoreApplication::processEvents() method and you can execute all pending queued events before they are naturally invoked

As a first step, ensure that your button clicked() event handler is connected explicitly through QObject::connect() method rather than through named connection. This way you can specify Qt::QueuedConnection to the button clicked() event handler while connecting it to your slot. (If you let the named connections automatically connect your button clicked event handler, then you will not be able to specify Qt::QueuedConnection. Named connections by default use the Qt::AutoConnection, which resorts to direct connection if on the same thread.) This Qt::QueuedConnection specification helps delay the button event handler till the event loop execution and might resolve some order issue.

Note that when the button clicked handler is called, the editingFinished() will be waiting in the queue to be process once your button clicked handler returns. To ensure that the editingFinished() handler is completed before, you can insert a QCoreApplication::processEvents() call in your button clicked event handler. This forces the event queue to be flushed and thus the editingFinished() be called at that point.

For example, OnBuildPreview() is the button click handler and SongRagaChanged() is the lineEdit valuechanged handler. We want SongRagaChanged() be called before OnBuildPreview() be called. But we cannot enforce Qt to this, so we make QCoreApplication::processEvents() inside the buttong handler (OnBuildPreview), to force the line edit handler SongRagaChanged() get complete first.

void PDFDocument::OnBuildPreview() // Handler for the button clicked
{
    // We need this to flush the events (so that any changes to song data get comitted first through SongRagaChanged())
    QCoreApplication::processEvents();

    if(m_pCMInputArea->OnCompile())            
        reloadPreview(m_pCMInputArea->GeneratedPDFPath());
}

void CMInputArea::SongRagaChanged(const QString &val) // Handler for text value changed
{
    CallSongItemMethod(SetRaga, val);
    m_pVerseRagaProp->AddEditListEntry(val);
}

- Gopalakrishna Palem, Creator of CFugue and CarMusTy