Emir Muñoz

Using Markdown for your presentations

Tue, 28 Oct 2014 00:00:00 +0000

This post is about how to use a plain text file to create a HTML5 + Javascript presentation. Among the few options, this time I will use KeyDown which is based on deck.js. An example presentation can be found in this link.

To start creating your deck, install the keydown builder:

$ gem install keydown

After that, we can generate a template from scratch with the basics.

$ keydown generate my_presentation

For those that worked before with deck.js this is an improvement making much easier the work.

The result of the generation is a folder with this structure:

| - my_presentation/
	| - css/				- keydown CSS and a file for you to customize
	| - deck.js				- deck library
	| - images/				- Some keydown images, but also for your images
	| - js/					- keydown JavaScript, and a file for you to customize
	| - slides.md

That easy is to generate the squeleton of the presentation. Now you can modify the file slides.md adding your content using Markdown syntax. Each slide is separated by a !SLIDE tag.

!SLIDE

# This is my talk

In the github repository of keydown you can find the details of how to add images and use the template.

After you add your content, you can generate the deck as a HTML5 file using the command:

$ keydown slides slides.md

For me that didn’t work so I checked the open issues and I found an answer in issue 34. I uninstalled compass 1.0.1

$ sudo gem uninstall compass

and installed compass 0.12.7 using the following Gemfile:

source 'https://rubygems.org'

gem 'keydown'
gem 'compass', '0.12.7'

and then executing bundle to build the deck.

bundle
bundle exec keydown slides slides.md

That did the trick and I finally got the slides.html file.

Once that everything is working propertly, edit the presentation is as simple as write Markdown. Then, the result looks good =) Now just use your arrow keys to move.

Using OpenRefine Review

Tue, 26 Nov 2013 00:00:00 +0000

[The publisher of this book provide me with a free e-copy for review]

Link to the book: http://www.packtpub.com/openrefine-guide-for-data-analysis-and-linking-dataset-to-the-web/book

My familiarization with OpenRefine started with Google Refine. The main idea has evolved and become open for contributions of the community. This book is a nice cookbook, easy to follow written in a friendly language, to perform both simple and complex operations over semistructured data such as HTML tables, spreadsheets, csv files, among others, exploiting the linkeability of your datasets with the Linked Open Data (LOD). Even without previous knowledge any user can take this book and from scratch start to use OpenRefine.

Organization:

The book is divided in four chapters plus an appendix.

Chapter 1: Presents the first set of easy-to-follow recipes to get your hands into loading and preparing your data.

Chapter 2: The main contribution is on how to sort and create facets to select (or isolate) data based on regular expressions over the cell values, with the main goal of fix the datasets.

Chapter 3: Tells you how to deal with more advanced operations over your data, and gives a brief introduction to GREL, the language defined to manipulate cell values. GREL is simple and powerful enough to match and replace the cell’s content as needed by different purposes, that’s because they have an appendix with a deeper explanation.

Chapter 4: Once that all the data have been normalized this can be reconciliated with an external knowledge base or linked open dataset such as Freebase (can be whatever knowledge base appropriate for the data at hands) to enrich the semantics of the data.

What I like about this book:

The format of cookbook and the easy reading are the most positive aspects of this book. The authors made a good work explaining all the use cases using a real data example.

What I dislike about this book:

The smaller things that I dislike are part of the format used in the book. It would be better to have enumerated figures and sections to make references effortless. However, the figures are very self explicatives and ad-hoc with the explanations. Also, for easy referencing would be nice to have a consecutive recipes numeration and not a new numeration in each chapter.

Wrapping up, I would strongly recommend this book to any user interested in: Semantic Web/Linked Data, Linked Open Data publication, Data Integration, Named Entity Recognition; at student, lecturer, practitioner level, or just for hobby.

Using Algorithm2e in ACM template

Mon, 26 Nov 2012 00:00:00 +0000

This post was first published on my Wordpress page link

If you have tried to use this package to create algorithms in the ACM template for papers, you must be come across this issue. If you only add the packate algorithm2e with something like

\usepackage[ruled,vlined]{algorithm2e}

you should have received a nice errors telling you “1616:Too many }’s” and “1617:Extra \fi \fi”.

To solve this annoying bug, that could make you lose a lot of valuable time, just add the following code before the import of the package.

% For algorithms in ACM template
\makeatletter
\newif\if@restonecol
\makeatother
\let\algorithm\relax
\let\endalgorithm\relax
\usepackage[ruled,vlined]{algorithm2e}

I hope this will be useful for you like was for me :)

Cheers!

Reducing space Theorems, Proofs, Lemmas, etc in LaTex

Mon, 26 Nov 2012 00:00:00 +0000

This post was first published on my Wordpress page link

If you need to make more space in your papers (space is valuable in this cases), because the (vertical) space between theorems, proofs, lemmas, remarks, examples, and definitions with other paragraphs is too large. Here I will show a little trick to do that.

We need to import the asmthm package. But, not too fast, this will trigger an error. So, above the import we need to add two lines that solve the bug related with an incompatibility in the proof enviroment (or macro).

Then we are ready to define our theorem style with the desire spaces and fonts as follows:

\let\proof\relax
\let\endproof\relax
\usepackage{amsthm} %http://ctan.org/pkg/amsthm
\newtheorem{theorem}{Theorem}
\newtheoremstyle{exampstyle}
  {\topsep} % Space above
  {\topsep} % Space below
  {} % Body font
  {} % Indent amount
  {\bfseries} % Theorem head font
  {.} % Punctuation after theorem head
  {.5em} % Space after theorem head
  {} % Theorem head spec (can be left empty, meaning 'normal')
\theoremstyle{exampstyle} \newtheorem{example}{Example}
\theoremstyle{exampstyle} \newtheorem{remark}{Remark}
\theoremstyle{exampstyle} \newtheorem{definition}{Definition}
\theoremstyle{exampstyle} \newtheorem{lemma}{Lemma}

This code will enumerate each enviroment –theorem, proof, etc– independly. If you are wishing to enumerate relatively to sections you have to use these modifications.

\let\proof\relax
\let\endproof\relax
\usepackage{amsthm} %http://ctan.org/pkg/amsthm
\newtheorem{theorem}{Theorem}[section]
\newtheoremstyle{exampstyle}
  {\topsep} % Space above
  {\topsep} % Space below
  {} % Body font
  {} % Indent amount
  {\bfseries} % Theorem head font
  {.} % Punctuation after theorem head
  {.5em} % Space after theorem head
  {} % Theorem head spec (can be left empty, meaning 'normal')
\theoremstyle{exampstyle} \newtheorem{example}[theorem]{Example}
\theoremstyle{exampstyle} \newtheorem{remark}[theorem]{Remark}
\theoremstyle{exampstyle} \newtheorem{definition}[theorem]{Definition}
\theoremstyle{exampstyle} \newtheorem{lemma}[theorem]{Lemma}

In the style you can customize the environments with your preferences and even create more than one style if necessary.

Cheers!

Sorting HashMap based on its values

Wed, 19 Sep 2012 00:00:00 +0000

This post was first published on my Wordpress page link

This task could be done in different ways. Here a discussion about some ways. In this post I will show one that I followed. Roughly speaking, the idea is convert the map into a list with the purpose of use the classic Collection.sort() method. The first think is that you need is to define a new class, that represents one map entry; and implements the Comparable interface. In this class you have to implement the compareTo method and override the toString (if you want).

import java.util.Map;
 
@SuppressWarnings("rawtypes")
public class CustomEntry implements Comparable
{
    private Map.Entry   entry;
 
    public CustomEntry(Map.Entry entry)
    {
        this.entry = entry;
    }
 
    public Map.Entry getEntry()
    {
        return this.entry;
    }
 
    public int compareTo(CustomEntry anotherEntry)
    {
        Integer thisIntegerVal = (Integer) (this.getEntry().getValue());
        int thisVal = thisIntegerVal.intValue();
        Integer anotherIntegerVal = (Integer) (anotherEntry.getEntry().getValue());
        int anotherVal = anotherIntegerVal.intValue();
        return (thisVal < anotherVal ? 1 : (thisVal == anotherVal ? 0 : -1));
    }
 
    public int compareTo(Object o)
    {
        return compareTo((CustomEntry) o);
    }
 
    @Override
    public String toString()
    {
        StringBuilder str = new StringBuilder();
        str.append(this.getEntry().getKey()).append(":").append(this.getEntry().getValue());
        return str.toString();
    }
}

Next step is to define the function that will convert any map into a list. Basically, this function will recover the entries in the map, and transform them into custom entries using the previous class CustomEntry.

import java.util.*;
import java.util.Map.Entry;
 
public class MapFunctions
{
    public MapFunctions()
    {
    }
 
    public static <T, E> List<CustomEntry> convertMapToList(Map<T, E> map)
    {
        List<CustomEntry> list = new ArrayList<CustomEntry>();
        Set<Entry<T, E>> entrySet = map.entrySet();
        Iterator<Entry<T, E>> iterator = entrySet.iterator();
        while (iterator.hasNext())
        {
            Map.Entry<T, E> entry = (Map.Entry<T, E>) iterator.next();
            CustomEntry customEntry = new CustomEntry(entry);
            list.add(customEntry);
        }
        return list;
    }
}

Now, you are allowed to execute the following instructions:

THashMap<String, Integer> map = ... /* some initialization */
List<CustomEntry> sortedList = MapFunctions.convertMapToList(map);
Collections.sort(sortedList);
System.out.println(sortedList);

and you will print the list of entries (from your original map) sorted based on its (original) values.

Cheers!

Research & Academia Blogs

Wed, 29 Aug 2012 00:00:00 +0000

LaTex Links

Wed, 29 Aug 2012 00:00:00 +0000

ShareLaTex:: Online pdflatex compiler that allow you to do a collaborative LaTex document.
Detaxify:: A great way of finding LaTeX symbols just drawing it.
TeXample.net:: Documentation about TikZ.
mathURL:: Live equation editing · permanent short links · LaTeX+AMS input.
WebEquation:: Write an equation and get the LaTex or MathML source.
MathJax:: An open source JavaScript display engine for mathematics that works in all modern browsers.

The following are examples of MathJax:

Complex formula:

\[\begin{align*} & \phi(x,y) = \phi \left(\sum_{i=1}^n x_ie_i, \sum_{j=1}^n y_je_j \right) = \sum_{i=1}^n \sum_{j=1}^n x_i y_j \phi(e_i, e_j) = \\ & (x_1, \ldots, x_n) \left( \begin{array}{ccc} \phi(e_1, e_1) & \cdots & \phi(e_1, e_n) \\ \vdots & \ddots & \vdots \\ \phi(e_n, e_1) & \cdots & \phi(e_n, e_n) \end{array} \right) \left( \begin{array}{c} y_1 \\ \vdots \\ y_n \end{array} \right) \end{align*}\]

The following is a math block:

Inline $5 + 5$ $$ 5 + 5 $$

But next comes a paragraph with an inline math statement:

$5 + 5$

Python and HTML Processing

Fri, 24 Aug 2012 00:00:00 +0000

This post was first published on my Wordpress page link

Trying to harvest some links from the Coursea Lectures, in a fast and efficient way saving me valuable time, I decided to use Python with Beautiful Soup.

Beautiful Soup is a Python library designed for quick turnaround projects like screen-scraping. It parses anything you give it, and does the tree traversal stuff for you. You can tell it “Find all the links”, or “Find all the links of class externalLink”, or “Find all the links whose urls match “foo.com”, or “Find the table heading that’s got bold text, then give me that text.”

First, you need to download the library from this link and untar the bs4 folder in your workspace. The library is really simple and intuitive to use, since represent the HTML document as a nested data structure.

Too much chatter, now I’m going to show you the python code :)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#!/usr/bin/env python
import urllib, sgmllib
 
# Get a file-like object for the Coursea Web site course page.
f = urllib.urlopen("https://class.coursera.org/gametheory/lecture/preview")
# Read from the object, storing the page's contents in 's'.
s = f.read()

# Here is the import for the library above described.
from bs4 import BeautifulSoup
# BeautifulSoup object, which represents the document as a nested data structure
soup = BeautifulSoup(s)
 
# Find all the link with rel 'lecture-link'
for videos in soup.find_all('a', rel="lecture-link"):
   link = videos.get('href')

   # Get the page apointed by the previous link in the same way
   f1 = urllib.urlopen(link)
   s1 = f1.read()
   soup1 = BeautifulSoup(s1)
 
   # Find all the source tags in the document and filter for 'video/mp4'
   for link in soup1.find_all('source'):
      if link.get('type') == "video/mp4":
      # You can concate 'wget' to build immediately an script
          print 'wget '+link.get('src')

A full documentation can be found here.

Be sure you have the bs4 folder and a file with the previous code in the same workspace. Then you can execute your python file as usual and get the links to download the video lectures that you want.

Cheers!

Path of Ubuntu Applications

Fri, 24 Aug 2012 00:00:00 +0000

This post was first published on my Wordpress page link

Usually I’m looking for the path where ubuntu installs some applications, here is a way to do it.

$ sudo dpkg -l | grep name_of_the_app

For example if you want to find what installed applications contains the word ‘emacs’ you have to use this,

$ sudo dpkg -l | grep emacs
ii  emacs                                  23.3+1-1ubuntu9                         The GNU Emacs editor (metapackage)
ii  emacs23                                23.3+1-1ubuntu9                         The GNU Emacs editor (with GTK+ user interface)
ii  emacs23-bin-common                     23.3+1-1ubuntu9                         The GNU Emacs editor's shared, architecture dependent files
ii  emacs23-common                         23.3+1-1ubuntu9                         The GNU Emacs editor's shared, architecture independent infrastructure
ii  emacsen-common                         1.4.22ubuntu1                           Common facilities for all emacsen
ii  python-ropemacs                        0.6c2-4

And then you can find all the files that this application contains.

$ sudo dpkg -L emacs23
/.
/usr
/usr/share
/usr/share/doc
/usr/share/doc/emacs23
/usr/share/doc/emacs23/copyright
/usr/share/doc/emacs23/README.Debian
/usr/share/lintian
/usr/share/lintian/overrides
/usr/share/lintian/overrides/emacs23
/usr/share/menu
/usr/share/menu/emacs23
/usr/share/emacs
/usr/share/emacs/23.3
/usr/share/emacs/23.3/etc
/usr/share/emacs/23.3/etc/DOC-23.3.1
/usr/share/man
/usr/share/man/man1
/usr/share/applications
/usr/share/applications/emacs23.desktop
/usr/bin
/usr/bin/emacs23-x
/usr/share/doc/emacs23/changelog.Debian.gz
/usr/share/man/man1/emacs23-x.1.gz
/usr/share/man/man1/emacs23.1.gz
/usr/bin/emacs23