Eliades Ochoa achieved world wide fame with his involvement in the “Buena Vista Social Club”. He has not slowed down.
If you listen closely to his works you’ll notice that his guitar playing is actually quite fantastic. Yeah, yeah, rock star X can shred your face off … lol!
Hailed as a “Cuban Johnny Cash,” Eliades Ochoa has an earthy sound and rustic style (topped off by his trademark cowboy hat) that is all his own. The Grammy-winning guitarist and singer was born in a rural mountain town, where he picked up his first tres guitar at age 6. He hasn’t stopped playing since. The self-described “Guajiro” (Cuban provincial) offers piquant renditions of son, guararcha, bolero and changuï, resulting in memorable collaborations with Bob Dylan and, most famously, Buena Vista Social Club. In 2006, he released Se Solto un Leon, a reference to his first album, A Lion is Loose. — from http://www.montrealjazzfest.com/artists/artist.aspx?id=7274
The JMockit Unit Testing library continues to astound. One new thing I discovered is its Coverage reporting.
Code Coverage Code coverage is simply a measurement of what code has been actually run when tests are executed. There are many such measures, ramifications, and tools. Like testing itself, code coverage measurement is probably not done enough, or misused.
“Code coverage tells you what you definitely haven’t tested, not what you have.” — Mark Simpson in comment
Path Coverage
Plenty of coverage reporting tools out there. What this one also includes is Path coverage. This is different then branch coverage. Paths are possible execution paths from entry points to exit points. If you visualize a methods statements in a directed graph, paths are a enumeration of the possible edges traversed when that method is invoked. So, Path coverages is inclusive of Branch coverage. Well, I’m not a testing expert, so this may be way off.
Very surprising results. For example, you run a coverage report with a tool such as Cobertura or Emma and feel very happy that you exercised every line and branch with your tests. Then you run the same tests but use JMockit Coverage and discover your tests didn’t cover all the paths! Not only that your line coverage wasn’t so great either.
Report
JMockit explicitly gives you a report showing:
Path
Measures how many of the possible execution paths through method/constructor bodies were actually executed by tests.
The percentages are calculated as 100*NPE/NP, where NP is the number of possible paths and NPE the number of fully executed paths.
Line
Measures how much of the executable production code was exercised by tests. An executable line of code contains one or more executable segments.
The percentages are calculated as 100*NE/NS, where NS is the number of segments and NE the number of executed segments.
Data
Measures how many of the instance and static non-final fields were fully exercised by the test run. To be fully exercised, a field must have the last value assigned to it read by at least one test. The percentages are calculated as 100*NFE/NF, where NF is the number of non-final fields and NFE the number of fully exercised fields.
– from the JMockit coverage report HTML page
Other information is found by using the full HTML output option.
Example
A sample JMockit coverage report is here. Of course you can drill down into various parts of the html page. Like when you click on an exercised line you will get a list of what invoked that line.
Worth it?
Are the metrics such as Path coverage that this tool generates accurate? Is JMockit coverage a replacement for other tools such as Cobertura? I don’t know. For most projects, the resources would probably make the use of coverages generated by multiple tools prohibitive.
Evaluation
One possible approach to evaluating coverage tools is to just use actual real results of the target application. Use the list of bugs and correlate to a coverage tool report. Where were the bugs? Which tool gave the least measure for this location?
Just finished seeing season one of “Downton Abbey” in Netflix streaming. What can I say that hasn’t been written before, it is grand. Such superb story, characters, filming, scenes, language, and most important great actors.
What I don’t get is why the household let Thomas come back to work?
Years ago I came upon the HSM concept. Is this now applicable in today’s networked world for personal use? I propose HSM can be extended to encompass the Cloud.
HSM is an enterprise data storage technique, a tiered storage. Data is automatically moved from expensive but fast storage systems like hard disk arrays to cheaper but slower systems like optical or tape drive.
Conceptually, HSM is analogous to the cache found in most computer CPUs, where small amounts of expensive SRAM memory running at very high speeds is used to store frequently used data, but the least recently used data is evicted to the slower but much larger main DRAM memory when new data has to be loaded. — http://en.wikipedia.org/wiki/Hierarchical_storage_management
In the consumer world we have in our PCs fast hard drives and on mobile devices fast flash memory. A simple two tiered system would migrate least recently used files from local media to the cloud. In the home or SOHO environment, a three-tiered system is possible. Solid-State Drives (SSD) of modest size could be the 1st tier, SATA disk the 2nd, and finally, Cloud services can provide the 3rd tier.
For example, you have a PDF on your system that is a great resource, but you haven’t used it in a few weeks. The HSM manager would take that file and move it to the cloud (secure, private, encrypted, …., of course). In its place, to allow access by the user, is a link to the HSM managed storage location. Next time you use the file it will be migrated back to the local storage (but now also backed up in the cloud).
Note that the HSM in enterprise systems is not simply based on “files” but on the underlying storage mumbo jumbo (frames, and all that).
This approach could make the potential future Windows 8 ‘Storage Spaces’ be even more useful. On *nix OS this is possible to implement now. It probably already is.
Demo
Here is a conceptual demo. We’ll use a known cloud storage service provider like Dropbox. As far as I know, Dropbox does not offer HSM.
On your PC you set a property on various folders that makes them eligible for HSM monitoring. This could be accomplished using a GUI and drag&drop. The HSM will immediately copy the folders to the SSD on your system or the main hard drive, if the files are not already on the fastest subsystem. In the original location of the folders, a link to the new locations will be created (soft links?). The end user will not see any difference. Kind of like “web folders” or WebDAV protocol.
After a period of time, the local HSM monitor will record which files have not been used and invoke the Dropbox local service to stream the files to the cloud. All that remains on the file system are links to the remote files; storage space is reclaimed.
Finally Windows may get a file system that adds features that have been around for years in Linux and Unix.
The state of the art in file system design could arguably be ZFS which is used in Solaris and a few other places.
Storage systems seem like very complex engineering systems. I wonder if Microsoft would have just been better off not reinventing the wheel and just licensing ZFS technology or something else? Just search for user horror stories regarding any of the storage improvements on Windows, from drive extender, encryption, WHS, etc.
And what ever happened to the object file system, the DB based file system?
Storage Spaces is somewhat like ZFS, although it has no deduplication and lacks other ZFS features. However, it is a start – and Microsoft will probably add features such as snapshots, replication, deduplication, and, maybe, compression. El Reg also thinks that there could be a Hyper-V virtualisation angle to this – and more is to come. — http://www.theregister.co.uk/2012/01/07/windows_8_storage_spaces/page2.html
Update
Jan 17, 2012: Ah, so Microsoft is working Resilient File System (ReFS).
Microsoft mentioned all the important keywords when promoting ReFS with words like resilience, availability and the use of storage pools, something made popular by Sun’s – and now Oracle’s – ZFS.
Source: The Inquirer (http://s.tt/15gRk)
This could be seen as application of the general ‘agent’ concepts I wrote about in one of my prior blog posts on Software Agents, “Synergistic Social Agent Network Cloud“.
Configuration of a development environment can be very time consuming, error prone, or difficult. This is especially true when investigating or getting up to speed on a new technology or framework. In a corporate environment this is a also a drain on resources and existing developer staff who must take the time to prep a new developer.
One approach to mitigate this is to use a Virtual Appliance.
Virtual appliances are a subset of the broader class of software appliances. Installation of a software appliance on a virtual machine creates a virtual appliance. Like software appliances, virtual appliances are intended to eliminate the installation, configuration and maintenance costs associated with running complex stacks of software.
A virtual appliance is not a complete virtual machine platform, but rather a software image containing a software stack designed to run on a virtual machine platform which may be a Type 1 or Type 2 hypervisor. Like a physical computer, a hypervisor is merely a platform for running an operating system environment and does not provide application software itself. — Virtual Appliance
Creating a Virtual Machine Applicance
The available VM software such as Oracle VirtualBox and the VMware VM have facilities to generate appliances. Thus, when a functioning development environment is created by a lead tech or group, an appliance can be generated for the rest of the team. This appliance can even be provided using a Virtual Desktop Infrastructure (VDI).
Open Virtualization Format
While a VM system can be used to create individual VM instances that can be reused, a more recent technology (supported by some vendors) is the use of OVF:
… is an open standard for packaging and distributing virtual appliances or more generally software to be run in virtual machines.
The standard describes an “open, secure, portable, efficient and extensible format for the packaging and distribution of software to be run in virtual machines”. The OVF standard is not tied to any particular hypervisor or processor architecture. The unit of packaging and distribution is a so called OVF Package which may contain one or more virtual systems each of which can be deployed to a virtual machine.
An OVF package consists of several files, placed in one directory. A one-file alternative is the OVA package, which is a TAR file with the OVF directory inside. — http://en.wikipedia.org/wiki/Open_Virtualization_Format
Using ready made appliances
Each VM vendor can/does make available an appliance marketplace. Thus, one can find ready-made LAMP based environments with a development software stack, for example.
Alternative 1, an installable virtual disk
Where resources are constrained, such as places where developers are still on 3GB of ram and ancient PCs, a Virtual Machine is just not going to cut it.
One easy alternative is to create a dev environment on an installable soft hard drive. TrueCrypt can be used for this purpose. One simply create a true crypt volume, which is just a single file. Then creates the desired dev env in that volume, and that file can now be copied to load into other dev’s workstations as a new hard drive.
TrueCrypt is really for security and privacy concerns, it encrypts data, so may not be ideal for this application. Since TrueCrypt is so useful as a virtual disk, it would be great if it had the option of not encrypting content. But, that would perhaps be outside of its feature space. For that the next alternative is available.
Alternative 2, use VHD files
An alternative is using something directly targeted at virtual disks such as the VHD file format. However, this does not seem to have easily useful public gui or command support (for the end user: developer).
On Windows following the instructions here and using these Send To scripts will allow one to seamlessly use vhd files as mountable hard disk volumes.
Note that Windows 8 will support native mounting of ISO and VHD files.
The WordPress.com stats helper monkeys prepared a 2011 annual report for this blog.
Here’s an excerpt:
The concert hall at the Syndey Opera House holds 2,700 people. This blog was viewed about 37,000 times in 2011. If it were a concert at Sydney Opera House, it would take about 14 sold-out performances for that many people to see it.
A very simple method of unit testing the output logging is presented using a state-based mocking approach and JMockit toolkit.
Context
Java language. Logging frameworks such as Log4j, commons-logging, java.util.logging, and SLF4J. Application logs.
Introduction
Unit test logging output? Isn’t that going overboard? Most likely. However, there can be some reasons why in certain parts of a code base you’d better:
Audit requirements
Logging adheres to standards such as Common Event Expression (CEE) language
Solution
In listing 1, a simple class uses the java.util.Logger to log. We want to make sure this class will always log this in the future, i.e., a regression test. In order to qualify as a unit test, the system under test (SUT) should be isolated. Thus, parsing an actual logging output file would not be optimal.
Listing 1
import java.util.logging.Level;
import java.util.logging.Logger;
/** Example class that logs. */
public class Service {
Logger logger = Logger.getLogger(this.getClass().getName());
public void serve(){
logger.log(Level.INFO,"Hello world!");
}
}
In listing 2 we use JMockit to mock the java.util.Logger. This should also work for other logging frameworks. JMockit has two approaches for applying mock techniques: Behavior-based and state-based.
We apply state-based below (just cause that is the one I’m starting to get the hang of). The Arrange, Act, Assert (AAA) pattern is still used, but the Assert step is in the mock object. We apply a simple ‘equals’ test, of course, based on what we expect in the log message, a regex may be more useful.
Listing 2
import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import mockit.Mock;
import mockit.MockUp;
import mockit.Mockit;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
/**
* JUnit test for Service class.
* @author jbetancourt
*/
public class ServiceTest {
private Service service;
@Before
public void setUp() throws Exception {
service = new Service();
}
@After
public void tearDown() throws Exception {
Mockit.tearDownMocks();
}
@Test
public final void we_are_logging_correctly() {
// Arrange
mockLogger();
// Act
service.serve();
}
private void mockLogger() {
new MockUp<Logger>() {
@SuppressWarnings("unused")
@Mock
public void log(Level level, String msg) {
assertThat("Hello world!", is(equalTo(msg)));
assertThat(level, is(equalTo(Level.INFO)));
}
};
}
}
Extensions
The above technique just tests that the log parameters are correct. This doesn’t check that the log output itself is correct. That is a different concern. Since the actual output logging is controlled by various configuration options, a unit test may not make sense. Would that be a functional test?
Summary
Shown was a little technique that may come in handy one day. Though presented in the context of logging, it is really a simple application of state-based mock use.
"According to the NSB, the U.S. lost about 687,000 jobs in high-tech since their peak of about 2.5 million in 2000." http://t.co/710zF17B------4 days ago
Posted by josefB 
