Params, Threads, Generics This is another progress demo. It involves: dynamically allocating params, genereics, threads, and switching between classes. Everything is handled transparently and effortlessly to the user. With such a small learning curve, ease of use, and blasting speeds the testing "Total Costs of Ownership" should be extremely low while attaining effectiveness never seen before. Enjoy your Sunday morning...

Plugging the plug-in

We are paying the error of working while sick on a key piece of code regeneration. Bad code, or at least worse than usual, that needs rewriting.

But it also has given us the opportunity of thinking about deployment.

We are toying with the idea of adopting "perpetual delivery" mode. Since the engine is not larger than 150K, downloading it can part of the add-in setup.

Time To Change...

Well after fiddling around with the load/stress engine + 1,600 threads/users for a while, I think it makes more sense to let users set the TTL per test.

It is easier for the user to set it according to their knowledge of the code than use any predefined formula.

It also becomes part of the verification data of the test which should be useful.

1,500 Threads in action

Well , we wanted to try a higher number on our load/stress engine. So, we tried 1,500. Watch and enjoy the execution times after the initial run (when all the setup occurs).

58 Seconds...

That is how long it takes to create, launch, execute, synchronize, and verify a load/stress session with DevRiot. Check it out for yourself...

Why wouldn't you want that level of efficiency in your SDLC? :-}

General Complexity

The Generics Generator is pretty smooth now:

This is an snapshot of a that involves: generic method, out parameter, multidimensional arrays, out of scope data (PrivateObject in VS parlance).

And it is the same as if it a method that takes and returns an integer. The user just spends time on what it matters most: substance and not boiler plate noise.

None of the competitors can achieve such a level of usability and ease-of-use. Let alone the execution speeds. We are pretty close to wire up the GUI testing engine...

Anything VUT...

Visual Unit Testing, this is the acronym that best describes the visual nature of DevRiot's user experience. It also applies to the GUI testing engine but there are more salient features that describe DevRiot's GUI testing engine: device independence and ditching the capture-and-replay paradigm.

Back to ironing out some bad bugs in the generics generator logic...

Params Row...

The thingy handling the params modifier is pretty stable now. There is a scenario where it NPE's but I am about to fix it. It is a little bit convoluted because it involves also the dynamic-scoping of parameters.

Next will be databases (offering a clean way for the user to test databases). Collections/Data structures will be partially supported for the beta. The GUI testing engine work will begin soon, hello .Net Compact we are going your way!!

Back on line!!

It arrived! After several weeks of waiting the snail mail to deliver the laptop converter. It arrived.

It was kind of an experience trying to order the spare part from here having bought the laptop in USA.

It would have been great if the surf had been less chaotic but winter storms can be messy around here.

Anyway, it is time to get back on track with the .Net beta :-}

.Nest My Private Arrays

Despite the hardware troubles we have been able to make some progress.

It is still a little bit unstable but we can dynamically define a series of nested arrays (arrays of arrays) of type A, and set the values of any private member.

And everything takes 3 clicks and 4 keystrokes. Try that with other solutions :-}

Stop!!

This is a not so good progress report. The development laptop batteries are not charding and the converter is not working :-}

I guess Dell will get another support call from around here.

Other than that, adding support for collections and modifying generics compilation is coming along well.

Time to wait...

Time Report...

Still working on how out/ref parameters are handled. We have been able to reduce the size of the execution engine by a good chunk. The goal was to make it small enough for the Compact Framework/J2ME.

But this means that the parameter processing needs some massaging. Out, ref, params can lead to some more spaghetti code than really needed.

Stuck here before fleshing out the widget handling logic (GUI testing engine)...

For Completeness' sake...

I just compared DevRiot for .Net against Nunit 2.4.3. DevRiot is 2,400+ times faster than Nunit.

And it includes GUI and Load/Stress testing, try to find those inside Visual Studio or Nunit :-}

The waves are just getting started. I'll try a two session day tomorrow :-}

The Fog of Fall...

Well after the dry and brown fall we have had so far (Galicia is like Seattle/Washington, rainy and green all year long) Some fog and rain has arrived last week, and with them some nice fall swells which I plan to take advantage.

As I mentioned in an earlier post, I managed to compare DevRiot .Net with Visual Studio 2008 Tools.

The performance of DevRiot .Net is really good, given we do not have access to any of the internals: on the low end DevRiot .Net is between 800-900 times faster than Visual Studio tools.

The time it takes Visual Studio to process the first test, DevRiot is close to 1,000. But if we reach the 100,000 tests, DevRiot outperforms Visual Studio tools nearly twice that figure.

As any sensible management guy would tell you: why waste time writing code to get slower?

I will be working on the GUI testing engine, particularly support for the .Net Compact Framework.

And, I will try to catch some waves. Enjoy...

Tick, Tick, Tick, Tick, Tick...

This has been a really productive week. I accomplished to run DevRiot for .Net under the new architecture for the first time.

Let's say I will hold off until early next week to announce the performance improvements...

Simple Update...

Well, just working in the guts of the engine now. Where the fireworks occur. No snapshots to show but really entertaining to fiddle with.

Still undecided of how to cache things for the compact framework devices but making great progress.

Context Adjustments...

Some times it is amazing where pointers to adjust features can come from.

And I have to say that MS seems to be on the ball supporting the extensibility community (not related to previous line)

Anyways, DevRiot's UI has changed a little bit to make things easier on inherited methods,fine tunning runs and having multiple instances of VS up.

We wanted to get this stable before get into the gui testing engine for .Net compact and device integration. It is going to be fun :-}

P.S. The second "Run Current Tests" really runs the whole suite.

Context it!!

We have done a little backtracking with regards of the original way we planned to handle assertions. Interfaces and abstract classes will be handled the same way: context strip.

Here is goes another snapshot of the work-in-progress:

What an eye sore!! (102,796)

Well, I finally managed to download all the components for Visual Studio 2008. It was long a process because of the size of the archives involved. Regardless, I have to say that the process was smooth.

Now to the substance, comparing DevRiot and the test tools of VS 2008.

I started with the basic: take an int and return it.

Nothing else fancier where DevRiot has advantage over VS: gui testing (on PC and devices, on and off screen), dynamic array/data structure manipulation, dynamic build test tress, built-in load and stress testing, etc :-}

It is an eye sore: test projects, test types, test attributes, test contexts, asserts, clicks, clacks to get to the point of to modify the test source to add the only thing that is of interest to the user: desired input and expected output. That is all a user needs. If the user needs to add a second test: repeat the process :-}

The thing is dog slow. It took (on average) 102,796 times more ticks than DevRiot. Granting that I was using Virtual PC but the times I am using for DevRiot are from 4 years ago on much slower machine than the current one I own.

If we assume a 50 times handicap (meaning that a 5000% improvement) DevRiot is still around 2000 times faster.

No wonder the execution time report is not the default one.

I tried to mess MS tool with changing return types, it choked like a child. Then I tried exceptions or even setting scenarios. It would have required getting into coding, api, etc..

I do not think they have clear concept of what automation means.

So, bottom line: why spend more time using MS QA infrastructure if it is not going to yield faster development cycles?

The pricing structure and road map discussion, I will leave for other post.

Off-topic:

Well, one thing led to the next. It started with using .Net 3.0 and the GUI testing engine, and ended up in: "we need to make sure that the off-screen engine works".

The off-screen engine is a feature of the GUI testing engine that allows these type of tests to run at speeds close to that of the unit test engine. The main goal is to increase the throughput of the process without losing accuracy.

BTW, it works...

Generics 3.0...

Adding support for generics is well underway but trying the GUI testing engine with WPF?

Help needs to be local, msdn needs to be installed...

Ohh well!

Autumn Nesting...

As my workload with Phurnace diminishes, DevRiot for .Net picks up.

Multi-dimensional array support is alive and well as the snapshot shows. Support for generics will take some time. The desktop and compact frameworks behave differently and the behavior of the engine needs to reflect this.

Well, the snapshot:

DynArray's P.S.

The one-click assert has been moved to a context menu where we will be able to provide a better way to handle assert conditions: greater than, etc, to return value, out parameters and post-test states...

DynArray...

The dynamic array, or data structures, logic is almost ready. We just need to add the dynamic shrinking to the nodes' context menu. Here we have a series of snapshots of how it's working:

1) Double-click the node to set or change the array length.



2) Type in the new desired length.



3) The tree readjusts itself.

One-click assert!

This is another of the progress snapshots: one click assert.

This feature allows the user to easily set the expected value, or range of values that an object should have. In this context a null or not null return value.

It does not matter if the object is private to a private field: just click away and forget about typing Asserts, PrivateObjects, or any of those rudimentary approaches!

Hit first, hit twice

Apparently USA's congress has changed the patent rules for a "first to the clerk" type of deal. Not good or bad, just a change in the playground.

DevRiot for .Net is coming along well, variable number of parameters and arrays are cleanly and dynamically handled.

Comparing usability with competitors...

Still doing interesting stuff with my buddies @ phurnace.

Prototipo; fundamentals, what fundamentals

The VS tool is coming along smoothly but a little bit slow. Phurnace's project has been quite interesting: started with a prototype with an rcp front-end and has turned into a WebSphere process server, web-services thing.

I have to admit that is highly interesting.

In this astonishing summer of news, there was this particular one about onshoring on cnn: an indian company was offshoring to Ohio some call center operations because the lower wages were not enough.

If the process and where economic value is created are not understood, there is little chance to success by trying anything else...

DevRiot for .Net is moving:

Forget about PrivateObjects, TestTypes, or writing code to create tests. Here is a snapshot of DevRiot for .Net:

Copyright (c) 2003-2007, efeKctive, L.L.C.

Hibernahhh...

Well, we are on our way to the airport. The "vacation" is over. For those with questions about De vRiot architecture:

It is totally homegrown. It was built to not depend on Xunit (as opposed to Agitar's) to gui testing, let alone hibernate.

Happy flights!!!

In the bay for more than a day...

Due to unexpected family emergencies, we will need to extend our stay in the Bay area for another week, were it not for the sad situation this would be a great change in plans.

We will try to make the most out of it. Some fine sushi dinner is waiting for us...

The trip to Austin was as expected, one meeting went well (the RCP project one) the other a no-go.

This friend of mine really needs to get her QA process faster, more manageable, and easier on the developers. But they have already started using junit and when things got difficult they turned to xml.

It felt like the moving sand trap, the more they moved deeper they sank. It was also challenging to explain how one could write tests without writing code and not to spill the beans.

Anyways, we will be around the San Andreas fault for another week.

.Net Progress, back to Bay Area, and other great escapes chapter...

Well, this RCP work does take its time but it is fun and it helps us. I have started to get the new architecture on Visual Studio together. This a little snapshot of the toolbar. (Not particularly different from DevRiot for Eclipse. And that's is the idea: lowering the learning curves...)

I also have been in touch with my friend to put DevRiot through the grinder of DataMining development. Progress but it will take time to show.

On another front, I have been meeting with some researchers from Santiago to start looking at the "writing engine" (so users will do nothing but look at test results and develop)

Finally, after 18 months I will be back to the States. The rest of the crew has been back several times but not me.

We will be visiting San Carlos/Bay Area. A new nephew is on the way :-}

I will post some pictures of an early spring trip to Costa da Morte which was quite pleasant: great waves and great seafood :-}

600--, 100++, Thread me!

Well, close to 600 downloads of the white papers. In little over a year, it seems like a good word-of-mouth.

The beta downloads have passed the 100 mark. With little prodding too. The interesting thing is that some of the downloads of Mac and Linux versions are coming from the Microsoft world(?)

I have been working more on my friend's project lately since we also have to pay bills :-} and working on the .Net add-in.

On the tool itself, another friend of mine came asking for help. This developer, like many others, was facing the daunting task of having to develop their own code plus the unit tests for that code.

In this case, there was also a lot of java, parallelism, and heavy database access involved. No wonder :-} Regrettably, our load and stress logic is not ready.

Hopefully, she will forgive me...

Variable Load!

Interesting visitors to our blog lately. Some have registered in the beta program, some have not.

We are looking at ways to cleanly allow the user invoke methods with a variable number of parameters. So far we are leaning towards double-clicking the parameters tab to insert a new parameter state tab.

The design on Load & Stress is going too. Before we try to measure memory and all that, we should make sure the user agrees with the state the object is after the beating. It requires some thought.

Why all that bloating?

As I move along with the VS add-in of DevRiot, I started to look again at the built-in features of VS.

What a mess! To end up asking the user the same information that DevRiot directly asks, there is an endless sequence of menus, options!

Orcas is following the same path. Why does the user need to deal with code? Because it executes faster? Obviously not.

That automatic code generation just works with native types. After that is back to set/get methods to set objects ready to tests. Or play PrivateObject nesting game.

Does it provide GUI testing for PC or devices? Nope.

Does it analyze build trees or AST? Nope.

Again, it is a step forward but short. Otherwise people would not still be asking "why white-box testing is ignored"

Beta FAQ:

A few questions have come up:

Do you Support Swing?

Yes. Actually, we are far along in that regard. We just wanted to release something that worked in J2SE and J2ME uniformly.

Swing is not an official J2ME package so we decided to remove it from the release.

How does the Private members access work?

Think of it as Visual Studio's PrivateObject but on steriods. And for Eclipse, too.

It is always there working for the user. But the user does not know it. The feature is transparent and does not require coding. It is also immune to refactoring changes.

It also works for all the types involved in a test (gui or unit): parameters, fields.

It also works like a drill: the user can click into an object state as deep as needed.

Is it only the plug-in/add-in?

No. The plug-in/add-in has two things in it: the plug-in/add-in logic and the reduced version of the engine. The plan would be to provide an automation server where the output of the plug-ins/add-ins are consumed and value added stats are gathered.

This could be provided as a service or as an attachement to SCM.