ssls.com review

Sometimes you need to provide encrypted traffic to your site. Besides proper configuration in web server you need to authenticate your server using some publicly trusted certificates, so your customer's browser won't show warnings about untrusted site. One of the cheapest SSL certificate solution is ssls.com. Let's check their price for 3 year lease: I used to pay $10 per year in the past for ComodoSSL certificates, this offer seems to cut the usual price in half. Sounds unrealistic? Let's check it!

Basic Hudson/Jenkins tutorial

Continuous Integration is a great thing. Allows you to monitor your project state on a commit-by-commit basis. Every build failure is monitored easily. If you connect your unit and integration tests properly also tell your runtime properties of the project, for example:

• Does it boot properly?
• Doesn't it crash in 1st 5 minutes?
• Are all unit tests 100% green?
• Are all static tests (think: FindBugs, lclint, pylint, ...) free of selected defect types?

The implementation:

• you encourage your team to push changes frequently to main development branch (having high quality unit testing suite you can even skip topic branches policy)
• you setup some kind of Continuous Integration tool to scan all the repositories and detect new changes automatically
• for each such change new build is started and tests are carries out automatically
• all the build artefacts (including tests outcomes) are collected
• the teams are notified by e-mail about build/test failures in order to allow them to carry out fixes quickly

OK, so we have outlined the plan above. Let's dig into details for every step. I'll use the most popular tool used named Hudson/Jenkins as implementation tool (there are two projects, but they're, actually, the same tool). I'm going to address all the features I expect from continuous integration system (based on my current experience with other CI systems).

CMake very basic tutorial

Writing Makefiles is a complicated process. They are powerful tools and, as such, show quite high level of complexity. In order to make typical project development easier higher level tools have been raised. One of such tools is CMake. Think of CMake for Make as C/C++ compiler for assembly language. CMake transforms project description saved in CMakeLists.txt file into classical Makefile that could be run by make tool. You write your project description in a high level notation, allowing CMake to take care of the details.
 

An Easy Executable Software Specification - A Proposal

Executable specification

is a "holly graal" of modern software engineering. It's very hard to implement as it requires:

• Formal specification of rules
• Transformation of those rules into real-system predicates
• Stimulating system under tests state changes in repeatable manner

FitNesse is one of such approaches that specifies function sample inputs and outputs then allow to run such test cases using special connectors and provide colour reports from test runs. It's easy to use (from specification point of view), but has the following drawbacks:

• Software architecture must be compatible with unit testing (what is very good in general: cut unnecessary dependencies, Inverse of Control, ...) - your current system might require heavy refactoring to reach such state
• Rules are written and evaluated only during single test execution - different scenario requires another test case (no Design By Contract style continuous state validation)

Above features are present in any other unit test framework: JUnit, unittest, ... All such testing changes state and checks output.

Setting up proper terminal size for serial connection to an embedded device

When you work over serial line on an embedded device usually the terminal size it set to 80x25.

There's an easy way, however, to setup your real terminal size, just add the following line to your profile script (~/.profile):

resize > /tmp/resize
. /tmp/resize

resize command detects real terminal size and sets COLUMNS and ROWS parameters accordingly:

# resize
COLUMNS=159;LINES=52;export COLUMNS LINES;

One just need to execute the output as sh commands (using source "." command).

Conflicting DHCP server locator under Linux

In order to locate conflicting DHCP server in your LAN execute the following command:

sudo dhcpdump -i eth4 | awk '/IP:/{SRC=$2 " " $3} /OP:.*BOOTPREPLY/{ print "DHCP server found:", SRC; }'

The restart your PC network (use DHCP to get new IP). If you see more than one IP address here:

DHCP server found: 192.168.4.1 (0:9:6b:a3:fc:4a)
DHCP server found: 192.168.1.1 (f8:d1:11:9e:1d:8b)
DHCP server found: 192.168.4.1 (0:9:6b:a3:fc:4a)
DHCP server found: 192.168.1.1 (f8:d1:11:9e:1d:8b)
DHCP server found: 192.168.4.1 (0:9:6b:a3:fc:4a)

Then you have two, conflicting DHCP servers in your network. You can use http://www.coffer.com/mac_find/ tool to locate the device type that causes the problems.

PlantUML - draw your diagrams declaratively

One picture is worth of thousand words. So true. Even if you describe some flow with many detailed paragraphs one sequence diagram might show the idea instantly to the reader much better than all the words.

Separation of diagram drawing software (Visio, Dia, ...) from your main documentation system (Google Docs, Latex, doxygen, ...) is not a good idea. Having no access to source of the diagram makes modification much harder to do (when original author is not available, you have, actually, re-draw the diagram from scratch to fix some minor change).

Text-based diagrams and some form of post-processing is the answer to above problem. You embed your documentation AND the diagrams in the document and tools change those into graphics when needed. Example of such systems cooperation is doxygen and plantuml.

Let's see how easy sequence diagram could be expressed in plantuml:

@startuml{sequence.png}
MainProcess -> Library: FacadeCall()
Library -> SSO: GetToken()
Library -> Server: CallService(token)
Server -> SSO: IsTokenValid(token)
@enduml

The result is rendered as diagram below:

There are more advanced functionality there, but I hope you have already caught the idea.

Next diagram type I'd like to explore is state diagram: