Thiago Ribeiro

Increasing productivity with Thyme app: a web version

2020-01-28T00:00:00+00:00

Looking for a way to increase your productivity?

Have you ever had those moments where you’re looking for an application to fulfill some specific need? I bet you have.

That’s how I found myself last year: looking for ways to increase my level of concentration and productivity while focusing on a single task.

Among the several ways you can accomplish that, for me, the main thing I was looking for was to simply track time spent working deeply on something (yes, Carl Newports’ Deep Work book did have an influence on that).

Although I did find several cool options out there (Toggl, Tickspot, etc), everything I tried didn’t feel right.

Some of the other solutions I found were either full of features I didn’t need, or I’d have to pay to use it or sign up to at least see it functioning.

Until I found Thyme. With no expectations (since it was free and open source), I downloaded it, tried it out for a couple of days and…loved it. The app was simple and straight to the point.

As I was using it, I was noticing how much more focused and productive I’d become while working on something and I am very sure the app has me helped to achieve that. I had finally found exactly what I was looking for.

My workflow with Thyme

It seems very obvious, but Thyme seems to get the UX involved in the process of tracking your time, more naturally by dividing it into three actions: start, stop and continue.

That idea contrasts with a lot of what you’ll see out there with the “Start” and “Stop” button titles only.

Even Google’s timer (Apple’s too I should say) shows the word “Start” when you stop the timer after awhile, which feels a bit weird to me since I don’t feel like I’m starting. I’m continuing or resuming (UI/UX folks out there, what do you think?) a task.

Back to Thyme, there is also a little feature that comes in handy, which is the export option.

Overall, the idea of a timer is straightforward, but the solutions I had found prior to Thyme all seemed overly engineered which distracted me from the real objective: helping me track how long did it take to finish a task.

Con: Thyme is Mac OS only

Hopefully I’ve convinced you that that little app is awesome by now, but the con is that Thyme is currently only written for Mac OS (until now I guess).

As I have been using Windows a lot for the past months, I just started to feel the void. The daily use of the app stuck like a habit.

It had become part of my daily activities and I was missing it a lot. It had definitely become part of my daily routine: sit down to concentrate, start Thyme. Then I had an idea…

Thyme Web version

I decided to create a web version of that lovely app, trying to mimic the experience you get on the Mac OS native app as much as possible.

As this is an initial version, and as one of the responsible for maintaining the OS X app (you can check the repository here), I’ve obviously also decided to make it open source.

The project is written in Angular and uses Web Workers to keep the timer being updated even if you switch tabs or minimize the browser.

The beautiful UI you see was created in partnership with Jandui (thanks my friend!) which I’ve successfully been able to convince to start navigating the open source world as well, haha.

This very first version is available here on https://thymeweb.netlify.com/

Current Features

Basic timer (just like the original Thyme);
Option to export list of worked tasks as .txt;
Tagging tasks when finished;
Local storage (tasks are kept even if tab/window closes);

Future Additions

Synching capability: since I have noticed that as I have the app installed in multiple Mac machines, and Thyme for Mac stores it locally only, I end up not knowing anything about my tasks from one machine once I switch to another;
Fully developed mobile UI: for now only the Desktop app looks good, but we’ve got some work to finish the mobile version of it;

Interested? please star the repo (https://github.com/tolribeiro/thyme-web) and help us spread the word about Thyme. You are more than welcome helping us out to build a better version of it :)

And I hope Thyme becomes as useful and helpful to you as it has been to me (I’ve used the web version to track the time I spent writing this post as well!)

Cultural training in programming: the pitfall of the Stack Overflow phenomenon

2019-12-14T00:00:00+00:00

A little story on cultural training: grandma’s ham

A couple of years ago I once read a fictional story on a book that resonated so much with me that I could never forget it.

It talked about a family event where a husband and his wife were in their kitchen and he was sitting at the table reading the newspaper while she prepared a ham for dinner.

At some point, he observed that she was cutting off about one inch from either end of the ham and then he asked: “Why are you doing that? that’s such a waste of good ham!” to which she promptly responded: “that’s the way my mom has always prepared it”. When he asked why her mom used to do that, the wife simply didn’t know the answer.

Now in the search for it, she called her mom to ask: “Mom, why do you cut the ends of the ham off?”. “Well, because that’s the way my mom used to do it”.

Though the wife’s grandma had passed away, her grandpa was still alive. Still without the answer, she then called him to ask: “Grandpa, would you know why my grandma used to cut the ends off of the ham?” He was silent for a moment and then replied, “Well, she used to do that so the ham could fit in the baking pan.”

This story illustrates what is often called cultural training which is when one generation (or employee) teaches or passes down a process or knowledge to another.

Stack Overflow: cultural training at scale

If you’re a software engineer or have interacted with them for long enough, you’ve probably heard of Stack Overflow at least once in your life.

Jeff and Joel giving a speech one year after the website’s launch (2009)

Created in 2008 by Jeff Atwood and Joel Spolsky (the same guy that created Trello, which I wrote about on my previous post), it’s a question and answer website for programmers to post about programming languages, problems and general issues.

As of January 2019, the platform had reached over 10 million registered users and it exceeded 16 million questions in mid 2018.

Given these absurd numbers, you can quickly realize the impact it’s had in the life of millions of programmers around the globe, becoming one of the most used tools used for helping to solve tough day-to-day questions and problems that are very common in the life of a software engineer.

But as the popular Peter Parker proverb states, with great power comes great responsibility. Now 11 years after its launch, it seems like the responsibility aspect of it is starting to catch up. The evidence is this article I stumbled upon recently that mentioned that the most copied Stack Overflow snippet of all time is flawed.

The answer to the the question “how do you print a byte count in a human readable format” or “how do you format something like 123,456,789 bytes as ‘123.5 MB’?” had been copied and embedded in more than 6,000 GitHub Java projects (!)…and it contained a bug. The admission came 9 years later from the author of the snippet itself, Andreas Lundblad, a Java developer at Palantir.

Now imagine that instead of a simple flaw, this snippet exposed some vulnerability that would put the application at risk?

That comes to show something I consider a recent phenomenon in our profession: it seems that a lot of us have become bound to simply replicate code or patterns without giving it a second thought or analysis, imitating exactly the same behavior of the fictional wife preparing the ham from the story above. In order to break that cycle, I’d argue that a simple way would be to willingly force ourselves to start using the word why more often.

I’ve always been a curious kid and soon have learned that in order to undersand something the best way, I’d have to ask myself why things are the way they are. I confess, though, that this is not always a self-conscious thought process that I go through for every thing I do in life, but it certainly is reinforced whenever I sit down to write code or design a solution to a problem.

Furthermore, one common thing I’ve seen a lot outside of the Stack Overflow example, is in large codebases where things were written a certain way and new developers tend to believe that since something is written or architected like that, then things should simply be replicated without questioning.

During my own journey, I’ve constantly tried to train myself to stop whenever I’m about to replicate a pattern, a snippet or a certain way of doing things, and ask: “why am I doing it that way?”. If I can structure my answer around a solid reason through at least some examination, then I feel like I can proceed. That has proven to help me build my confidence in the very early stages of my career and until today has kept me challenging myself to see things on a different light.

Taking your Trello board to the next level: essential plugins to boost its power

2019-11-30T00:00:00+00:00

Why and when to use a process like Kanban?

One of the most important parts of the process involving the design and analysis of systems is the proper choice of the methodology to be used throughout the implementation phase.

In the case of systems modest in size, operating with relatively small teams, aiming to release software early and often without having to follow the constraints of a more rigid approach, a list of ideal characteristics that fits these requirements would probably look something like this:

Little to none distinction amongst roles;
High flexibility to change;
Estimation based on cycle time;
Variable prioritization;

Sounds familiar? well, yes. We are describing Kanban.

In the very early phases of Jamp, we naturally discovered that this methodology worked great for us and have decided to keep it until today.

Are there good Kanban tools out there?

As you might’ve guessed, with a very quick search you can find several long lists with tools that can be leveraged to implement Kanban into your project.

However, for one reason or the other, Trello seems to be the go-to tool when we think about it.

Maybe because of its simplicitity, maybe because it’s free and with out-of-the-box features ready to use, or simply because it seems to be the best on the market (in my personal experience, I always seemed to go back to it after trying out others).

Pro4Trello & Parent/Child Dependency (PCD)

Although Trello holds its reputation through the advantages mentioned above, if you need to rely on it for collecting metrics or even trivial tracking, it usually doesn’t get you too far.

The only way I found to keep using it and still extract valuable data from it, was by using these two amazing Chrome extensions: Pro4Trello and PCD .

What are the advantages of using these extensions?

Categorization

Since we have a couple of different systems and applications to keep track of, we’ve decided to use the Pro4Trello’s categories feature per card and we divide them between iOS, Android, Website and others.

So the user would start by typing the name of the category, then writing the description of the card after the pipe:

Category1 | This card is to describe a certain feature...

Tagging

Each card that gets added to the board needs to specify its type through a tag. In our case, we have US (for User Stories) and DE (for defects).

Category1 | This card is to describe a certain feature [US]

Identification

Since we need to keep track of which changes to the codebase are related to each cards, this feature allows the developers to have an auto generated ID for each card created that can be used for branching or commit messages.

Prioritization

Another key thing to differentiate cards is the ability to mark some as more important than others. For this, the plugin allows you to simply specifiy the level of priority of a card by using !, !!, or !!!.

Estimation

The person creating the card can also add the estimation for the time that is going to be spent on the task by adding a {} with the time inside the curly braces.

Dependency

Finally, as sometimes needed, a task is dependent on the other and for that we use PCD. Every time you open a card, this plugin shows a dropdown list that you can relate the current open card to its dependent.

Real life example: defect on iOS app

Given that we need a card to track a defect (tag:[DE]) from the Jamp’s iOS app (category: iOS) where the text gets truncated for words of more than 10 characters and it’s a critical issue (prioritization: !!!).

The developer estimated that it’d take 1 hour to fix it. Here is how the card would be created for Pro4Trello:

iOS | {1h} !!! Fix truncated text for words of more than 10 characters [DE]

The plugin would then process these formatting from the card and display it like this:

Notice that it created its own id #1, which is the one used for commits and branches.

Now the most incredible part is that Pro4Trello organizes all the data for you on a tab below the board, where you can simply filter your cards (category, tags etc) and have the board display it for you:

Therefore, by the end of each cycle (be it a week or two), you can archive the lists and they can be easily searched by dates from the default Trello search option whenever you need to pull some data regarding your development cycle.

That way, we’ve been able to fully function as a small concise team by leveraging these tools, eliminating the need to spend on more powerful ones since we’d only make use of some of the thousands of features these more robust tools usually provide.

Easy event tracking using Segment and Google Analytics

2019-04-01T00:00:00+00:00

Truth is always to be found in simplicity, and not in the multiplicity and confusion of things Isaac Newton

This quote from Newton has recently become my motto. Along with the divide-and-conquer approach to problem solving, these two ideas together become a powerful concept to remind yourself of whenever a challenge comes up.

Not that integrating some analytics into a project should be something very complicated to accomplish, but depending on the documentation of the service you want to use and the task at hand, things can get a bit tricky.

It should not be painful…

If you’ve had experience integrating third-party APIs into any project, you’ve probably had to deal with some unpolished docs out there that instead of clarifying stuff, leave you even more confused than when you started reading them.

Here is an important point on that: when a company’s target market involves developers, this is something to keep an eye on. John Collison from Stripe can back me up on that when he affirms that their great API and documentation were important factors for Stripe’s success.

And that’s where Segment comes into play.

KISS principle at its core

On that matter, Segment definitely got it right. Learning to integrate event tracking into your project becomes very simple, straight to the point. Let me show you an example.

Let’s suppose you have a search bar on your website and you just need to track the words people are searching for. Check this out (Javascript):

analytics.track ("Searched", {
  searched_word: "medicine",
});

That’s all you’d need: the action you want to track, and the property to capture the user’s searched word.

Nevertheless, even though you can send all sorts of custom properties to Segment (and check them on the debugger for testing purposes), it apparently does not keep these values stored in there. For that, you have to connect your project to a destination (such as GA) you want to send these events to so they can be stored, exported and analyzed there instead.

Checking the searched words on Google Analytics

Once Segment is receiving your events and they match the payload you expect on the debugger, you need to create the link to GA. Here are the steps:

Create Custom Dimensions on GA: this needs to be done so Segment can link the custom property name you chose, to these “dimensions” (or variable names);
Map property to dimesion index on Segment: on the GA settings on Segment (Destinations), link them using its index:
Select the Dimension for the event action: Once you get to the Events page and select the action (“Searched” on our example), you can select the Custom Dimension and you’ll be able to see the list of searched words.

That way, you can leverage the amazingly powerful features of GA and Segment’s event tracking library all at once.

Next time you need to track events on your website or app and you already use Google Analytics, this is definitely a combo you should try out since I do not think it can get any simpler than that!

From local to public with ngrok

2017-02-23T00:00:00+00:00

For years I had played with server-side apps locally, running and testing it on my machine and not showing it to the world, since, you know…it would take me some extra effort to deploy it somewhere. However, everything changed when I got to know about the wonders of ngrok. It works like magic.

It’s not my intention here to anylize ngrok’s key features since its own documentation and this amazing article by Phil Nash cover it all thoroughly (by the way, if you’re a Windows user, check this one by Devin Rader), but I can show you a basic usage, so you can get it up and running in seconds.

Running ngrok on Terminal

Since it’s built in Go and packaged as a binary, the downloaded file is a Unix Executable (Mac) and you run it passing http and the port (80 by default) as arguments. On Terminal:

./ngrok http 80

What happens next?

So considering this website (my own), when I use jekyll serve, Jekyll automatically serves it on port 4000 (default), so I can access it locally through http://127.0.0.1:4000. In case I write a new blog post or change something on it and want to show it to someone, with ngrok I can specify the port (./ngrok http 4000) and it’ll generate the link for me (you can also set a password, check Phil’s article):

Now you use the public link URL http://bbfdf75e.ngrok.io, which will tunnel whoever you shared it with to http://127.0.0.1:4000.

You can already see the beauty of it: in my case, no need to push my modifications anywhere in order to show what I’ve been working here to someone. If you’re developing an application on your machine and need to show progress to a client but couldn’t bother deploying it, now you’re good to go. Kudos, Alan Shreve!!

Sound Level Meter with ESP8266, Arduino and iOS: IoT device for sound monitoring

2016-01-10T00:00:00+00:00

The purpose of the project: mapping noise in cities

Nowadays, even without noticing, we have been surrounded by a lot of noise. This noise comes from all sorts of sources such as bars, cars, trains, parties and so on. When this noise starts affecting our well-being or health, we give it a name: noise pollution.

Therefore, my idea was to create a device that would be cheap to assemble and that could be installed in certain areas of the city, constantly updating data about sound levels to a web server and making them available to the population.

The hardware: Arduino, Sound Level Meter and ESP8266

In order to measure the sound level (analog value), I decided to use the SparkFun Sound Detector (SSD). This little IC has three outputs: audio, gate and envelope. As the purpose is to measure the amplitude of sound, to me, the envelope output is what separates this board from the others (figure below).

Besides, the Arduino UNO works as the “brain” in the system. Regarding the interaction with the SSD, it reads the envelope output into the analog port A0 and converts it to a value in decibel, a logarithmic scale used in sound measuring.

Additionally, the ESP8266 module (figure below), this extremely versatile IC was used as a station, connecting the hardware to the local network using WiFi. It is important to mention that the more advanced versions of the ESP have an ADC port, which would exclude the use of an Arduino. However, in order to make it work for this project, two ports of the Arduino were used to transmit and receive data from the ESP (TX and RX).

Assembling the parts on a breadboard

After assembling the parts on a breadboard, I noticed that the user should be able to read the output data in two forms: being near and far from the device. Thus, I added a regular LCD that would print the status and the measure in decibels. Furthermore, three LEDs would be able to alert the user about the loudness: if the green one is on, it means the place is quiet, if yellow the ambient noise is moderate and if red, it’s loud.

After doing a couple of tests with the ESP using a voltage regulator, I noticed that the response of the module is better when powered by a clean voltage source, which explains the two batteries used to exclusively power it, once the module works with 3,3V.

The software: iOS App reading the data

As a way of testing the system, I used the ThingSpeak server to update data directly from my device to the cloud. By using their API, I could read the data coming as a JSON object, parse it, and print it to the user. I set some pins on the map, where the user would hypothetically choose the place he wanted to monitor, and then notify by email or call in case it is being loud.

The points on the map are from a central part of Recife, the city I live. The idea is to have several devices spread around a given city, updating data about how noisy is the location at any time. Finally, in the video I explain how the hardware and the software work together. :)

Understanding Graph Coloring (vertex): C++ code and visual graph in LaTeX (Part II)

2015-12-28T00:00:00+00:00

In the previous tutorial, we explored a very simple approach, step-by-step, to color a graph using the three colors available (blue, red and yellow).

Now we’ll put that approach into practice by using a C++ implementation (from the awesome guys at GeeksforGeeks) of that algorithm and my contribution to it, that was among others features, to generate a visualization of the graph colored by using the worldwide famous and open-source tool LaTeX and the powerful TikZ package.

How to input the graph info: `input.txt`

One of the most important parts of the program is the method that actually colors the graph using the greedy approach.

However, before the greedyColoring() call, that actually colors the graph, the input.txt file is where you enter the information about your graph G(V,E).

The first line is the number V of vertices and the following ones should contain the edges E. Let’s say we have the graph below:

The input file should look like this:

By doing so, the program will read that as G(5, 7) meaning your input graph has 5 vertices and 7 edges which connections are explicited in the lines.

The `greedyColoring()` method

This method contains the main part of the code, which is the result array. This result array of size V is responsible for storing the final colors assigned to the vertices.

int result[V];

// Assign the first color to first vertex
result[0] = 0;
	
// Initialize remaining V-1 vertices as unassigned
for (int u = 1; u < V; u++)
    result[u] = -1;  // no color is assigned to u

The first color assigned is going to be 0 and the algorithm assigns the remaining ones as it goes through the adjacency list.

As a result, the final result vector for the input graph illustrated here looks like 0, 1, 2, 0, 2 (5 vertices from 0-4) meaning that vertex 0 is colored in 0, vertex 1 is colored in 1, vertex 2 is colored in 2 and so on.

To handle the output in LaTeX, I created an array that chooses a real color based on the index, i.e., to get the color represented by the number:

	string key_value_colors[] = {"red", "yellow", "blue"}; // choose color based on index - 0 is red, 1 is yellow etc.

Therefore color 0 is red, color 1 is yellow and color 2 is blue. The program replace them by the ones set in key_value_colors.

`LaTeX/TikZ` code generated

By running the C++ code we get a .tex file that can be compiled to see the result of the algorithm graphically. It’s important to mention that in order to automatically see the .pdf you need to have LaTeX installed so the pdflatex command is recognized by the Terminal (Linux/Mac OS). Besides, the output for this example should be:

Finally, in order to demonstrate how to use the program, I recorded this video where I show how to go from a regular graph as the input to the graph colored in a .pdf file as the output.

Understanding Graph Coloring (vertex): a greedy approach (Part I)

2015-12-21T00:00:00+00:00

It is known that the problem of coloring a graph with the smallest number of colors needed (finding its chromatic number), is part of the set of NP-Complete problems.

However, there are methods that can be used to color vertices sequentially, by choosing the colors based on the colors already assigned in the vertex’s neighborhood. In other words, we can use what is called a greedy algorithm to solve the problem.

To explore this approach, imagine that you have a palette with 3 colors available, and the following graph to color:

Knowing that you cannot color vertices that are adjacent to each other with the same color, the step-by-step process to color the entire graph of Figure 1 is described below:

Let’s say we choose the first color blue (ordered from left to right), to color vertex 1;
Intuitively, we already know that vertices 2 and 3 cannot be colored by blue anymore, because they are adjacent to 1. Thus, following the order, for vertex 2 we choose the next available color and it is red;
The next vertex to color, 3, is also adjacent to 1 and 2, and by that we know that neither blue or red can be used to color it, so the next one available is yellow.
The last vertex, 4, is only adjacent to vertex 2. This tells us that the only color we cannot choose is red. Then going back to the first color available, vertex 4 is colored by blue (it could have been yellow).

One of the applications that I like the most and where graph coloring can be applied is the frequency assignment in cellular networks. In order to avoid interference (or crosstalk), different frequencies are assigned to adjacent cells, and the total number of distinct frequencies should be minimized.

Therefore, if you instead of considering the colors blue, red and yellow, consider them as frequency 1, frenquency 2 and frequency 3, the algorithm that we manually applied to the graph above could have been very useful to configure a simple cellular network or any similar schema described as a graph.

In the next part we’ll be going through a C++ implementation that generates code that can be compiled in LaTeX using Tikz, where we’ll be able to see it working for generic graphs.

Capacitor charging graph web app in JS

2015-05-04T00:00:00+00:00

Recently, I faced the task of analyzing the graph of a capacitor in a simple circuit configuration: a voltage source powering the given capacitor connected to a resistor in series.

The result of this configuration is pretty straightforward: my capacitor will get charged with a certain value of voltage from the source (almost 100%), respecting the exponential function described below:

We can easily see that it corresponds to a time versus voltage (exponential) function, where the RC element is what we call time constant. If you multiply the value of your capacitance with the value of the resistance that you have configured in your circuit, the result will represent how long it took for your capacitor to get charged with approximately 63% of the voltage from the source.

As an example, let’s suppose we have a 12V source powering a 1000uF capacitor connected to a 51k resistor: it would take 51 seconds for the capacitor to have stored approximately 7.5V between its terminals.

Solving the problem: Javascript + Google API

As I didn’t have an oscilloscope, an analog port from a microcontroller board, nor any other resource that would help me to see the graph with the values of time and voltages plotted instantly, the first idea was to use the timer from my cellphone, marking laps and then after plotting the graph on another specific software.

Thus, I thought that it would be really nice to have an application where I could put it all together (timer, time constant calculation and plotted graph) in one single page. The hassle of switching between my phone and my circuit, having to write down the values of times, made me think of this solution that I called Cap-Charge.

First version and demonstration video

Although I think it would be better to work on all the single bugs and put the almost perfect solution, I decided to put online a very first version (0.1) so as other people use it, we can keep improving it together. I also recorded a video for those who are interested in using it and seeing how it works (Link is here).

I’ve also realized that the application can be very helpful to use in lab experiments in general, so I hope it optimizes your time whether you’re doing it in school or at home. Please let me know if you have any questions. Have fun!

Simplified DES (SDES): an implementation in C

2015-01-12T00:00:00+00:00

A few months ago, I went through a quite challenging experience as a student of an introdutory class on Criptography: I was required to give a presentation on DES algorithm.

After going through the titles of the reliable books on the subject, I decided to read Criptography and Network Security by William Stallings and one of the first sentences on that page caught my attention:

“The structure of DES and most symmetric ciphers is very complex and cannot be explained as easily.”.

Therefore, in the next paragraph, it said that studying a simplified version (SDES) would enhance the understanding of DES, and I can guarantee that it actually does.

After a couple of hours struggling in the beginning, I finally got the idea behind one of the most important symmetric ciphers algorithms.

The encryption process

The simplified DES operates on a 8-bit block of plaintext to generate a 8-bit block of ciphertext. These types of algorithms are called block ciphers. It also uses a 10-bit key, generating two subkeys in the process, used as input for the most delicate part of the algorithm, the fk function.

The scheme below shows how the plaintext (input) is manipulated to generate the ciphertext (output).

After all these steps, the output is the encrypted input.

The keys generation step

This step only involves single permutations and shifts. I strongly believe that if you take a look at the implementation you won’t have any problems understanding it.

The decryption process

DES is a symmetric cipher, which means that it uses the same key to encrypt and decrypt the data. Since my idea was only show the step-by-step encryption process, I decided not to write the function to decrypt it.

However, you might not have any problems doing it either, because the only thing you’ll need to do is the encryption process backwards, i.e.: output -> IP(output) -> fk(output, k2) -> SW(output) -> fk(output, k1) -> IP Inverse (output) -> input.

The implementation in C

Based on the scheme shown above, I implemented the algorithm and came up with the encrypt function, that summarizes the encryption process of Simplified DES.

// ------------------------------------------------
// ---            Encrypt Function   		---
// ------------------------------------------------

void encrypt(char *input, char *key)
{
	initial_permutation(input); // IP
	fk(output, k1); // fk with subkey k1
	switch_halves(output);	// SW
	fk(output, k2); // fk with subkey k2
	initial_permutation_inverse(output); // IP Inverse
}

To make it easier to understand, I tried to stick to the names of the variables. The variables input, key (also the subkeys k1 and k2) and output literally mean the same as on the scheme.

You can download the full implementation here or from my Github.

Final Considerations

This algorithm was developed by Professor Edward Schaefer of Santa Clara University. I recommend that you read the appendix from Criptography and Network Security, explaining the algorithm in details (here).

Furthermore, take a look at this PDF document (here), written by Professor Steven Gordon of Sirindhorn International Institute of Technology, which contains some examples that you may want to verify with my implementation.