Today Software Magazine

No. 1 / 2012 • www.todaysoftmag.com

TSM

T O D A Y S O F T WA R E MAG A Z I NE

The problem of side effects From an idea to a product Creative compensation Startups - Mintaka Research

6 The problem of side effects

Ovidiu Deac

8 Performance of .NET applications Flaviu Măţan

16 The Good, the Bad and teh Ugly

26 StartUp Mintaka Research Marius Mornea

30 From an ideea to a product Ovidiu Măţan

33 Creative compensation Ioana Fane

Ovidiu Deac

22 Interview with the Finalist Team at Microsoft Imagine Cup Marius Mornea

36 5 differences between a lider and a boss Aristotel Dascăl

38 10 vs. 1700 Presto - Allegro ma non troppo Aurel Popârţac

editorial

Connecting the dots Hello, Welcome to our first issue of Today Software Magazine. The initial idea of having this magazine came up from the need to connect software engineers, project managers, HR specialists and create a virtual community that promotes new ideas and good practices based on people experience. Most software engineers get the news from global portals, specific websites or from inside their companies. There are few ways to find out what others like you are doing, most of the time we are reading guides, APIs or books. What we will try to do starting with this issue is to connect the dots and let you know what other software engineers are doing.

Ovidiu Măţan, PMP Coordonates Gemini Solutions Cluj’s team, in the past worked as a Product Manager for Ovi Sync at Nokia, founder of Today Software Magazine.

The second goal is to promote startups from the software industry. Trying to help them to get a better audience and of course to let our readers find out about what can be done today. At least one startup will be presented in every issue. So, if you have recently started your own business, send us your story.

The third goal is to create a virtual team of professionals who will become known by publishing regularly in the magazine. A part of this team is already there but there is space to grow. If you think you have something to say, send us a draft and your article may find its place in the magazine. The coverage area starts from software engineering, QA, automation to management and HR. One interesting section we are considering for you is the philosophical section. I hope you find our first issue a pleasant reading and send us your comments on the portal. The magazine is mostly online, with few printed copies for our collaborators and marketing purposes. So if you like it, we are counting on you for sharing the link with others.

In the current issue we are starting a lot of stories that will continue in the next months. Functional programming is one of them and it is showing a different approach than common object oriented paradigm. How to start building your own product or service from an initial idea is giving you a little flavor of product management. One of our collaborators is promoting his startup, Mintaka Research, which is a good example of how real businesses can take advantages of scientific research.

There are more interesting articles you will find in our magazine. Let’s keep in touch!

Regards,

Ovidiu Măţan Founder Today Software Magazine

4

no. 1/2012 | www.todaysoftmag.com

TODAY SOFTWARE MAGAZINE

Editorial staff Founder / Editor in chief: Ovidiu Mățan / ovidiu.matan@todaysoftmag.com Graphic designer: Dan Hădărău / dan.hadarau@todaysoftmag.com Translator: Nora Mihalca / nora.mihalca@todaysoftmag.com Editor (Startups / Interviews): Marius Mornea / marius.mornea@todaysoftmag.com Editor (Programming languages): Ovidiu Deac / ovidiu.deac@todaysoftmag.com Collaborator: Ioana Fane / ioana.fane@todaysoftmag.com Collaborator: Flaviu Mățan / flaviu.matan@todaysoftmag.com Collaborator: Aurel Popârţac / aurel.popartac@todaysoftmag.com Collaborator: Aristotel Dascal / aristotel.dascal@todaysoftmag.com Reviewer: Romulus Pașca / romulus.pasca@todaysoftmag.com Contact address str. Plopilor, nr. 75/77 Cluj-Napoca, Cluj, Romania contact@todaysoftmag.com www.todaysoftmag.com www.facebook.com/todaysoftmag twitter.com/todaysoftmag ISSN 2284-6360

www.todaysoftmag.com | no. 1/2012

5

Programming

The Problem of Side Effects

Ovidiu Deac Independent software consultant specialized in agile development methods and functional languages.

In his free time, he likes swimming, mountain climbing and motocross racing.

Known under the acronym OOP, the Object Oriented Programming was introduced in the ‘60s with the language Simula67. It’s the paradigm used by most of the software shops. It is supported by the mainstream programming languages like Java, C#, C++, Python, Ruby.

OOP is an imperative paradigm which means that the program describes the way the system state is changed during the execution. The system is modeled through classes of objects. Each class describes the state variables of its instances, their properties and the actions that we can run on them. Through encapsulation we hide the implementation details and this way the user of the class is only interested in the interface exposed by that class. This way we can model the world around us. It seems like a very natural approach but still there are a few major problems.

The problems start from the fact that, except for the constant methods, all the member functions produce side effects because they change the state of the object on which they are called or the states of other objects they have access to. Most of the object-oriented code is written this way.

A function/method/procedure should return a value but sometimes it produces side effects such as: changing data outside the function scope, interacting with the operating system/virtual machine (create file, processes, threads), allocating or deallocating resources, throwing exceptions etc.

A function which does not produce side effects and it’s not influenced by the exterior is a pure-function and its result depends only on the input parameters.

Next I will talk about the problems produced by the “impure” functions and I will try to show the advantages of building applications mostly on pure functions.

Testing

The global mutable variables used in the code are usually a source of problems.

Whether they are simple global variables or singleton objects, they are in fact the same: mutable data accessible from multiple places. Code written like this is very hard to test because the value of a variable could change unexpectedly. This way there are many execution paths which aren’t obvious. In order to be able to understand them, we will have to read code outside the tested function.

Even more, we can say that a function which has side effects is harder to test because the behaviour of the system depends on the order in which all the side effects are produced. So, in order to test that function, we will have to test all the possible scenarios in which it could be called together with the other functions that produce effects of the given type.

Improvement of the system testability can be done using mostly pure functions. In many cases they are trivial to test because they don’t need setup/teardown

6

no. 1/2012 | www.todaysoftmag.com

TODAY SOFTWARE MAGAZINE

as they don’t depend on external components. Their result only depends on the input parameters.

Parallelism

When an object is used from several execution threads we need a synchronization mechanism.

Ideally the execution threads should be independent; otherwise synchronization will make the system to be used below its maximal capacity. Any interaction between the threads slows the system. Another problem is the cache coherence when several processors share mutable data. Even more, if the system is a distributed one, the problem is increasingly difficult because synchronization costs are higher.

Another aspect is the difficulty to understand code which runs on several threads. Synchronization bugs are probably the most difficult ones because they are surprising and are hard to reproduce.

Ideally the objects used from several execution threads should be immutable.

The data would be transmitted to the thread using asynchronous messages. This way the developer doesn’t have to deal with the complexity of synchronization primitives but instead he works at a higher level which is easier to understand.

This is the pattern called “thread pool pattern” which consists of several worker threads and each thread receives messages which describe the job. They execute the job and put the result in the result queue.

It is very important that the worker thread doesn’t change data outside and it only produces a result based on the job description message.

Using some standard queuing mechanism the problems are easily solved. This way it’s much easier to write a parallel or a distributed application. The main reason is that our worker doesn’t produce side effects - i.e. it’s a pure function.

If the worker only has access to immutable data, it can copy its data locally at runtime and this way it won’t need any kind of synchronization. If we write some massive parallel application, the lack of synchronization is a major advantage.

Asynchronous Execution

There are many situations when we need to execute a certain sequence in an asynchronous manner. Next to the normal parameters, the asynchronous call will need a result handler function. This style of working is pretty difficult in the imperative style. The problem is the fact that in the imperative paradigm the order of execution is important.

The order is important only because the functions produce side effects. If we had no side effects, the problem would be one of establishing the dependencies between the data. We wouldn’t care how much the calculations took or the order in which they were performed. We would only care that the results are available when they are needed.

This way in an asynchronous call we obtain a promise-like result called “future” which will eventually be used for calculating another “future” etc.

Optimizations

The theory says that we should optimize only when the functionality is in place but some optimizations are hard to do if the code produces side effects. For example, profiling shows us that a certain function could run in parallel. With a pure function implementation the change from sequential to parallel execution is much simpler compared to the case when the function produces side effects. Furthoremore, pure functions allow us to easily change some calculus from synchronous to asynchronous late in the development.

Besides parallelism and asynchronous execution pure functions allow us to easily do other optimizations such as lazy execution or memoization.

development it’s important that they don’t produce side effects and the evaluation itself is a pure function.

Memoization

Another frequently used optimization is the memoization. It is similar to caching and it works in situations when a function is called many times with a given set of parameters. It is done by storing the result of the calculus. When the next call is done we look up the results in the already-calculated-results map instead of recomputing it.

This could be convenient when a certain calculation is repeated many times and the look-up is less expensive than the calculation itself.

If the function which does the computation produces side-effects, the memoization cannot be done. In exchange, if we have a pure function, it is almost trivial.

Conclusion

The problem of object oriented programming comes from its philosophy that the objects can change their state in time.

Applications written this way are built mostly on functions which produce side effects. The whole concept of side-effect is treated lightly in OOP and in imperative programming in general.

If we paid more attention to the side effects produced by the functions, the resulted code would be simpler, more robust, easier to parallelize and optimize.

In the following articles from this series we will discuss about functional programming which is different from imperative programming mostly in how it handles the problem of side effects.

Laziness

In some situations we want some calculus to be performed only if needed. For example we want to load a module only if it is really used.

If the module loading produces side effects, then this optimization can be difficult or even impossible.

As a conclusion, in order to change evaluations from strict to lazy late in the

www.todaysoftmag.com | no. 1/2012

7

Programming

Performance of .NET Applications

Flaviu Măţan Principal Software Engineer at Ixia

8

no. 1/2012 | www.todaysoftmag.com

Modern dynamics of software development with focus on frequent deliveries of working code makes performance an often overlooked aspect.

Although approaches such as “Make it work first and refactor it later” have demonstrated advantages like easy and quick adaptation to changes of requirements, they often open the door to poorly written routines that affect performance in a negative way.

Whether included in the development cycle from the very beginning, or caused by circumstances such as the discovery of very slow operation or abrupt performance degradation in certain scenarios (e.g. increasing the number of entry points such as the number of users that use a system etc.) or as a step prior to a scalability task, the measurement of application performance is a very important step in the lifetime of an application.

This is the first in a series of articles on the performance of .NET applications and it’s about choosing a profiling tool that suits your needs. The second article in the series will be a case study that will analyze common sources of performance degradation and provide potential solutions to these problems.

Choosing the right profiler

Detecting performance problems in an application can be done in different ways, starting by using the wrist watch for measuring the execution time of different operations, adding timers around operations that are suspect for performance problems and logging the measurements and ending by using dedicated performance profiling applications that provide complex measurement data collected at application runtime.

The first option is successfully used by top management to evaluate an application’s performance.

The second version that uses timers scattered throughout the source code works well when the performance problem is relatively known and isolated and one wants to narrow down to its cause. This is usually a sequential process involving multiple steps leading eventually to identify the problem in the code.

In the first part of this series of articles on performance in .NET applications we discuss the third option, the one where performance profiler applications are used.

Next we’ll compare two of the best commercial profilers for .NET applications: Redgate’s ANTS Performance Profiler and dot Trace Performance from JetBrains.

Their evaluation will be based on several criteria including: ease of use, accuracy of measurements, results analysis, price etc.

TODAY SOFTWARE MAGAZINE

1. Ease of use

Both applications are very similar in terms of starting and configuring the profiling session.

Each allows the user to choose the type of the application to be analyzed (standalone app, Silverlight, web etc.) as well as the options related to the accuracy or detail level for the collected data (line level, method level or sampling method).

The most common profiling options are described. Most of them are present in both profilers under different names: 1. Profiling mode: Sampling - is a small accuracy profiling mode in which all threads are periodically suspended and the call stack of each thread is saved. Based on the collected call stacks the profiler can estimate the duration of each method call.

The advantage of this method is that it has the smallest influence upon the application under test in terms of duration of execution. The disadvantages include the lack of hit count for methods and low accuracy for methods duration.

Tracing or Method-level profiling is the most common profiling method in which measurements are performed based on notifications received from the CLR (Common Language Runtime) upon entering and leaving the methods.

The advantages include high accuracy measurement of time spent in methods and the presence of the hit count for all the functions.

The most important disadvantage is that this profiling mode has a relatively big influence on the performance of the application under test.

Line level measurement produces the most detailed measurements containing functions duration and a hit count at a line level.

The biggest disadvantage is the major influence on the application being profiled.

2. Method of measurement: Wall time - represents the execution time measured between entering and leaving a function. The time spent by threads in sleep, wait and join operations are also

Picture 1 - Session initiation for standalone application profiling, ANTS Performance Profiler 6.3

Picture 2 - Session initiation for standalone application profiling, dotTrace Performance 4.5.1

www.todaysoftmag.com | no. 1/2012

9

Programming

included in this measurement type CPU time (thread time) - counts only the time a thread is actually using CPU. The time spent by threads in sleep, wait and join operations is not included in this measurement type.

3. Other options Methods for duration adjustments to offset the profiler’s influence - if this option is enabled, the estimated profiler influence upon the execution duration is subtracted from the measured duration giving method durations that are closer to the real execution (without a profiler attached).

Note on the table notation: Yes* represents my personal preference between the two. It influences scoring by counting +2 instead of +1 (in the case of normal Yes) for the profiler having it.

Score: ANTS Performance Profiler 6.3 dotTrace Performance 4.5

8 6

Obtaining the profiling results

The two profilers have different mechanisms to collect profiling data between two points in time: ANTS Performance Profiler 6.3 has the notion of timeline and dotTrace Performance uses the notion of snapshot.

Performance of .NET Applications

Windows

Selecting a window on the timeline will update the data collected in the analysis window corresponding to the time interval determined by the window.

Windows selections can be created around a certain operation, a CPU spike or the entire execution.

Selecting a window around a particular operation (e.g. opening a document) can be a tricky thing because it requires storing / identifying the starting and ending point of the operation. The sequence of actions for selecting a particular operation would be as follows: we are just about to perform the operation we’re interested in optimizing or finding the performance issues; right before performing it we want to make sure we’ll be able to identify the starting point for the window. If there is a UI action (e.g. mouse click) involved to issue the operation we’ll just need to identify the corresponding marking on the timeline (as I said before, UI events are marked on the timeline).

If we don’t have such a UI event, the things get trickier as we need to mark the starting point somehow. Personally, I usually create a temporary (small) window just before beginning the operation and I stretch it at the end to create a window that contains the whole operation. Other alternatives in-

It is updated in real time as the profiled application is running and displays information such as CPU load chart, I/O (read/ write) chart, exceptions and UI events that occurred during the execution.

The timeline is interactive, allowing the selection of windows, zoom in / out, click on exceptions and events to get additional information about these and save selections (windows) in the form of bookmarks.

Bookmarks

Bookmarks are saved along with saving the profiling results. Bookmarks are very useful when one wants to return to previously saved profiling results and to review profiling data for certain operations or areas of interest. In the absence of bookmarks one should redo the windows from scratch for certain operations and would run into the identification of window limits problems discussed above in the Windows section. Creating bookmarks to mark the relevant windows at the moment we first created them facilitates one click retrieval of profiling data for an operation. Those at JetBrains have solved this problem using the notion of “snapshots” to automatically structure the collected data on time intervals defined by the user.

Pros and Cons Timeline’s advantages include maxiANTS Performance Profiler 6.3

dotTrace Performance 4.5.1

Sampling

Yes

Yes

Method level

Yes

Yes

Method level (only modules with source code)

Yes

No

Line level

Yes

Yes

Line level (only modules with source code)

Yes

No

Time adjustment to eliminate the profiler's estimated influence

Yes

Yes

Wall time

Yes

Yes

Thread time

Yes

Yes

ANTS Profiler timeline

I must admit that the timeline is a sophisticated and spectacular control.

clude searching the entry point method in the call stacks but the drawbacks show up if there are multiple calls to this entry point and we only need a specific instance to analyze. Or if the operation subject to profile involves a sequence of methods. A single window can be selected at a time. Its dimensions can include any subset of the timeline.

Table 1 - Profiling options

10

no. 1/2012 | www.todaysoftmag.com

TODAY SOFTWARE MAGAZINE

Picture 3 - Selected timeline section to get the data for that time interval mum flexibility in selecting time windows of any size, additional information such exceptions and UI events.

Among the timeline’s disadvantages: - Difficulty in creating windows around specific operations - Profiling data collection is active throughout the execution influencing the performance of the profiled application.

both profilers such as using the same set of metrics (functions hit count, duration of methods etc.), outlining the most expensive methods, filtering methods with very low impact, mapping with the source code etc. There are distinct and useful features on both sides regarding presentation and grouping of methods, searching and annotation capabilities, etc.

dotTrace snapshot

2.1 Viewing the results

dotTrace Performance has a simple data collection mechanism to collect profiling data in the form of snapshots. Thus the programmer chooses the exact time to start the profiling data collection and when it stops, the end result is a snapshot. A snapshot cannot be combined with other snapshots.

Pros and Cons Advantages: - Data collection is active only during the snapshot capturing reducing the impact on profiled application performance (The performance impact of the profiled application when there’s no snapshot in progress is not zero. The process is instrumented and all the hooks are active, only the profiling data collection and structuring is stopped.)

- Collecting data for a specific operation is easy (start / stop snapshot)

Grouped by thread Both profilers have a thread based, tree-like, sorted (descending) by duration, method calls visualization mode. It can

Picture 4 - start data collecting

Definitions: Call stacks - all the function call stacks are recorded for each thread along the entire profiling data collection Note: Both profilers have an option to filter the methods that are irrelevant (take very little time) from the displayed function stacks. The user may choose to suspend filtering in both profilers.

Percentage - the contribution of a particular method to the entire duration of a thread expressed in percentages. This percentage also includes the calls to child methods (method calls within the function).

Note: This percentage is always present in the tree display of dotTrace Performance Profiler. In the case of ANTS profiler there’s a column called “Time With Children” and its values can be expressed as a percentage or absolute time (milliseconds or seconds).

Method duration - - represents a method’s own time without including the time spent in child method calls.

Note: In the tree visualization mode only ANTS Performance Profiler has this column Time with children - see the description above at Percentage Hitcount - represents how many times a method was called within a particular call stack.

Disadvantages: - Snapshots cannot be expanded or shrunk (as with the timeline)

2. Analyzing the results

Both applications offer users an arsenal of features that facilitate finding the performance problems in the applications under test.

There are basic elements common to

be noticed that the two representations are similar in terms of displayed contents (function signatures, durations, hit counts).

Picture 5 - stop data collection

www.todaysoftmag.com | no. 1/2012

11

Programming

Performance of .NET Applications

Picture 6 - Tree-like profiling results grouped by thread, ANTS Performance Profiler 6.3

Picture 7 - Tree-like profiling results grouped by thread, dotTrace 4.5.1 Performance Other presentation and grouping modes: Flat List Both profilers have the flat list visualization mode where the functions are no longer grouped by specific criteria (such as per thread) but are listed and sorted by user defined criteria (e.g. descending by duration, hit count, name etc.).

If a certain method is called in multiple stacks (threads), the method will appear once in the flat list view and will have cumulated duration and number of calls from all the contexts in which it is called.

2.2 Drill down

Once we identified a suspicious function we want to drill down to the main cause(s) of the performance issues of that method. In the tree visualization mode one can expand the function tree down to the leaf child calls.

This is a very common operation that

12

no. 1/2012 | www.todaysoftmag.com

can become frustrating if one needs to make the drill click by click especially in situations where the stack is very deep.

ANTS Profiler solves this problem by offering an option to automatically expand the most expensive stack trace starting from the selected method.

Unfortunately, in dotTrace Performance 4.5.1 there is no such option having to sweat a little in order to get down to the bottom of the stack.

The ANTS Performance Profiler 6.3 offers the option to display the calls tree for a particular function (the root function) in a graphical way. This visualization mode, besides the nice looks, offers a great and user friendly way to drill down.

The graphical mode is entered from any of the other visualization modes (tree or flat list) by right clicking the desired function and choosing call graph from the contextual menu. In the graphical mode one can move up or down from the selected function to the callers or callees respec-

tively. A very useful option is offered to automatically expand the most expensive (in terms of duration) subtree.

Another very important aspect of this visualization mode is the option to export the graph in PDF or image format providing a very easy way to share the results with other people.

The equivalent drill down method offered by dotTrace Performance is opening the method in a dedicated tab. The called methods percentages will be relative to the root method.

Both approaches (ANTS and JetBrains) present the same data in a different way, leading eventually to the same results.

However, the call graph approach offered by ANTS is friendlier to navigate (especially for big hierarchies), due to the “expand most expensive path� and zoom in/out features.

Searching Searching for a specific method is quite used during profiling results analysis, especially when we know exactly which

TODAY SOFTWARE MAGAZINE

Picture 8 - Flat mode profiling results, ANTS Performance Profiler 6.3

Picture 9 - Flat mode profiling results, dotTracePerformance 4.5.1

Picture 10 - The Graphical Mode (only ANTS)

www.todaysoftmag.com | no. 1/2012

13

Programming

method we want to watch or in order to see the effects of optimizations made for certain methods.

At this aspect, dotTrace offers a much better search control featuring just in time suggestions list filtering.

ANTS prefers a simple control, not offering suggestions or namespace-aware search.

Results Comparison Between the two, only dotTrace Performance 4.5.1 provides the ability to compare results obtained in two different profiling sessions through the snapshot comparison feature.

I must admit that I’ve rarely used this functionality as the compared snapshots need to be similar in terms of function calls order and hit count.

In optimal conditions however, the feature can be very useful in evaluating the effects of a performance optimization.

Annotation / markup Another feature offered only by dotTrace Performance is the annotation / tagging of methods in the profiling results.

Users can add comments for specific methods and can highlight outstanding functions by changing the formatting and colors.

Performance of .NET Applications

Simulate optimizations Only the profiler from JetBrains provides such functionality via the Adjust Time feature selectable from the context menu for a method. The adjustment can be made by sliding down from 100% to a percent representing the estimated gain after a potential optimization. The adjustment can be applied to the current stack or to all stacks in which the method appears.

3. Affecting the performance of the profiled application

Both profilers affect the application under test both in terms of performance and consumed memory.

In the table below there are performance measurements for both profilers made on a test application (the demo application that comes with dotTrace Performance 4.5.1): From the measurements in the table we can draw some obvious conclusions: - sampling mode has insignificant influence upon the profiled application for both profilers - tracing mode (or method level) ANTS Performance Profiler 6.3

dotTrace Performance 4.5.1

Display the results per thread (tree- like)

Yes *

Yes

Display the results as a flat list

Yes

Yes

Annotation of methods

No

Yes

Drill down at method level

*Yes

Yes

Searching

Yes

Yes*

Comparison of results

Yes

Filter low impact methods

Yes

Yes

Ability to export results in easy to transport formats

Yes

No

Simulate optimizations

No

Yes

14

no. 1/2012 | www.todaysoftmag.com

takes a little longer with dotTrace than with ANTS attached - at line level things are very different as with dotTrace profiler attached the application runs over three times slower than in the case of ANTS. Note that one can apply filters that specify which modules / classes / functions are to be included or excluded from the analysis at the line level.

- The last two modes (without data collection) are only available in dotTrace Performance Profiler and are very important when analyzing specific operations. In this scenario one can choose to run with the profiler attached but not to start collecting profiling data. This makes the profiled application to move much faster (tracing mode is significantly faster than ANTS).

The advantage of this mode is even more obvious when expensive operations (such as opening a large file) are to be executed prior to the specific operation we want to profile.

In this case the time to get to the point when the profiling data collection is started will be significantly reduced.

The influence on the memory used by the profiled process is significant. It can become up to 3 times higher than running without a profiler attached. This means that profiling of memory intensive applications can end up with an Out Of Memory exception. Both profilers have similar influence on the memory.

Another (undocumented) influence that profilers have upon profiled applications is on the threads timing which can reveal threading synchronization related bugs (such as race conditions and dead locks) which did not manifest before.

4. Complexity of profiled applications

From my experience with both profilers I can say that ANTS profiler is less usable than dotTrace’s when it comes to profiling very complex desktop applications (memory and CPU utilization wise) mostly because of its heavy UI. Timeline selection becomes laggy. Displaying the profiling results for a selected window takes very long time. I’ve even encountered hangs and red Xs on the

TODAY SOFTWARE MAGAZINE

UI controls that made the profiler unusable any further and the profiling results lost. dotTrace Performance Profiler on the other hand is not affected by this aspect, remaining as usable as with any other profiled application.

5. Other Criteria

Profiling I / O and SQL - ANTS Performance Profiler 6.3 only.

The functionality is provided only for operating systems newer than Windows XP Professional and only in the Professional edition of the profiler.

Results portability and post profiling investigation - ANTS allows to export the full set of profiling results in html and xml formats. The call graph of a function can also be exported in PDF or image format - moving and opening the full profiling results (in their binary format) is easier for the results obtained with dotTrace Performance Profiler as each snapshot is saved in its own file compared to the corresponding ANTS profiler file which contains the data for the entire profiling session.

Ability to attach to a process - ANTS Performance Profiler 6.3 offers the option of attaching to a running .NET 4.0 process. dotTrace Performance Profiler doesn’t offer any process attaching functionality.

Integration with Visual Studio - Both profilers integrate with Visual Studio allowing the profiling session to be launched directly from the IDE. Price - dotTrace Performance Professional 4.5 costs 569 Euros - ANTS Performance Profiler Professional 6.3 costs 595 Euros

Operation duration without profiler attached: 10s

ANTS Performance Profiler 6.3

dotTrace Performance 4.5.1

Sampling

10,1 sec

11,7 sec

Method level

50 sec

1:13 min

Line level

4:20 min

14:38 min

Method level (no profiling data collection)

N/A

36 sec

Line level (no profiling data collection)

N/A

7:08 min

Table 3 - Profiler’s influence on the application under test in different profiling modes

6. Conclusion ANTS Performance Profiler 6.3 dotTrace Performance 4.5

25 21

Both profilers will help you successfully solve the performance problems in your applications. Each of them has its own useful set of features that the other doesn’t have and both offer the basic functionality at equal levels.

Depending on the specifics of your application one profiler may suit you better than the other.

My advice is to try them both to make an idea on what each has to offer and which best suits you.

dotTrace Performance Profiler 4.5: http:// www.jetbrains.com/profiler/download/index.html ANTS Performance Profiler 6.3: http:// www.red-gate.com/products/dotnet-development/ants-performance-profiler/

Trial versions for the two profilers can be downloaded from the following locations: ANTS Performance Profiler 6.3

dotTrace Performance 4.5.1

Profiling I / O and SQL

Yes

No

Portability results and analysis later

Yes

Yes*

Export html / xml the entire result

Yes

No

Ability to attach to a process

Yes

No

Visual Studio Integration

Yes

Yes *

Price

euro 595

euro 569

www.todaysoftmag.com | no. 1/2012

15

Programming

The Good, the Bad and the Ugly

Ovidiu Deac Independent software consultant specialized in agile development methods and functional languages.

In his free time, he likes swimming, mountain climbing and motocross racing.

In this series of articles I would like to compare various programming languages. In each issue I’ll pick a small problem which will be solved in different languages.

We’ll try to keep the problems simple in order to concentrate on the approaches taken in different languages. Even if you are not familiar with the syntax of a language, you should try to understand the approach and then consider its advantages and disadvantages.

The problem for today will be solved using Java, Python 3 and Haskell. The choice of the languages was done so that they were as different as possible. The first, Java, is an imperative object-oriented and static typed language. It is probably the most used language today, thus a good reference.

The second is Python 3 which is still an imperative language. Due to its dynamic typing and its functional programming features, combined with the objectoriented features, it gives us a different perspective.

The third is Haskell. This is totally different from the other two. First of all, it’s a pure functional language and the side effects produced by the functions are specified in their type signature. Then it’s a static typed language but it supports type inference. This means that, most of the time, the type signatures are not needed.

The Problem

Let’s write a minimal command interpreter which reads from standard input commands and prints their result to the standard output. The accepted commands are ls and cat. ls

• • • cat

• •

lists the directory content prints an error message if more than one parameter is provided lists the content of the current directory when called without parameters

prints an error message when called without any parameter when called with one or more file names as parameters, it displays the content of the files like this: file1:...file2:...

16

no. 1/2012 | www.todaysoftmag.com

TODAY SOFTWARE MAGAZINE

The program will exit when the user hits Ctrl+C or when the standard input is closed (Ctrl+Z on Windows and Ctrl+D on Linux)

Java

The following code is Java. It has about 3,000 characters on about 110 lines. I ran it on Ubuntu Linux 11.10, using openjdk 1.6.0 like this:

javac Shell.java && java Shell

Being a well known language the comments regarding the syntax are probably unnecessary. The source code is next, except the imports. public class Shell { public static void main(final String[] args) { try { final BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); String s; System.out.print(“>”); while ((s = in.readLine()) != null && s.length() != 0) { try { final String output = execute(s); System.out.println(output); } catch(Exception ex) { System.out.println(ex.getMessage()); }

}

System.out.print(“>”); } System.out.println(); } catch (IOException ex) { System.err.println(ex); }

private static Map<String, Command> CMD_MAP; static { final Map<String, Command> tmpMap = new HashMap<String, Command>(); tmpMap.put(“ls”, new Ls()); tmpMap.put(“cat”, new Cat()); CMD_MAP = Collections.unmodifiableMap(tmpMap); }

}

private static String execute(final String cmd) { final String[] splitCmd = cmd.split(“ “); final String cmdName = splitCmd[0]; if (!CMD_MAP.containsKey(cmdName) ) { throw new RuntimeException(“Bad command: “ + cmdName); } else { final Command commandObject = CMD_MAP.get(cmdName); final String[] params = Arrays.copyOfRange(splitCmd, 1, splitCmd.length); return commandObject.execute(params); } }

The next class is needed because the standard library lacks a function which joins a list of strings. One can find these functions în third-party libraries but I tried to stick to the standard library.

www.todaysoftmag.com | no. 1/2012

17

Programming

The Good, the Bad and the Ugly

class Util { public static String join(final Object[] items, final String sep) { final StringBuilder sb = new StringBuilder(); int index = 0; for (final Object item: items) { sb.append(item.toString()); if (++index < items.length) { sb.append(“\n”); } } return sb.toString(); } }

Next is the interface command with the implementation for cat and ls. interface Command { public String execute(String[] params); } class Ls implements Command { @Override public String execute(final String[] params) { if (params.length > 1) { throw new RuntimeException(“Too many parameters”); } else if (params.length == 0) { return executeImpl(“.”); } else { return executeImpl(params[0]); } }

}

private String executeImpl(String dir) { final String[] files = new File(dir).list(); return Util.join(files, “\n”); }

class Cat implements Command { @Override public String execute(final String[] params) { final List<String> list = new LinkedList<String>(); if (params.length == 0) { throw new RuntimeException(“No files to cat.”); } for (final String file: params) { list.add(catOneFile(file)); } }

}

18

return Util.join(list.toArray(), “\n”);

private String catOneFile(final String file) { try { final String contents = new Scanner( new File(file) ).useDelimiter(“\\Z”).next(); return file + “:\n” + contents; } catch (Exception ex) { return “Could not open file ‘” + file + “’”; } }

no. 1/2012 | www.todaysoftmag.com

TODAY SOFTWARE MAGAZINE

Python 3

Python 3 code was run using CPython 3.2.2. It has around 1,250 characters spread on 65 lines. I chose version 3 of the language just to promote it. The code is mostly compatible with 2.7, the only difference being the way the lines in stdin are read in the loop “for line in stdin”.

Next is the code with comments in places where I felt the syntax is strange.

First of all, as it’s an executable script, the file starts with #! like any linux executable script. This way we can run it from the shell like this: $ ./shell.py

...and, because of the #! the shell will know which interpreter to use. #!/usr/bin/env python3 PROMPT = “>”

Next is the main function which iterates over the lines in stdin. Note that the function prompt is inner inside main because it’s the only place where it is used. To avoid name collisions, it’s recommended that you minimize the scope of the functions. def main(): from sys import stdout,stdin def prompt(): print (PROMPT, end=””) stdout.flush()

The function ls has the parameters *args which means that the args variable is a tuple with a variable number of components, depending on the number of parameters the function was called with. def ls(*args): from os import listdir if not args: return ls(“.”) elif len(args) > 1: raise Exception(“Too many parameters”) else: dir_content = listdir(args[0]) return “\n”.join(dir_content)

The function join of the class string joins a list of strings given a separator. For example: “,”.join([“a”, “b”, “c”]) will return “a,b,c” def cat(*path_list): if not path_list: raise Exception(“No files to cat.”) def cat_one_file(path): try: with open(path) as f: content = f.read() return “%s:\n%s” % (path, content) except: return “Could not open file ‘%s’” % path contents = [cat_one_file(path) for path in path_list] return “\n”.join(contents)

print(“Ctrl+C to exit”) prompt()

CMD_MAP = {“ls”: ls, “cat”: cat}

for cmd in stdin: try: print(execute(cmd)) except Exception as ex: print(ex) prompt() print()

The CMD_MAP above is a dictionary which associates the key “ls” with the function ls and the key “cat” with the function cat. As you can see the functions are used as normal variables.

The only thing telling that they are functions is the fact that they are called using the syntax function_name(param1, param2, param3).

Below is the function split_cmd which returns a tuple containing two values which are unpacked by the caller. Then we search the command name in the CMD_MAP dictionary. If found, we obtain the function implementing the command, we call it with the given parameters and return the result.

try: main() except KeyboardInterrupt: print() exit(1)

def execute(cmd): def split_cmd(): cmd_parts = cmd.split() return cmd_parts[0], cmd_parts[1:] command_name, params = split_cmd() if command_name in CMD_MAP: command_function = CMD_MAP[command_name] return command_function (*params) else: raise Exception(“Bad command: %s” % command_name)

The code above makes the call to the main function and handles Ctrl+C. Code 1 is returned if Ctrl+C was hit. The fact that I put the exit outside the main function is a matter of taste. Since exit closes the program abruptly, for me it feels cleaner to use it only outside main.

www.todaysoftmag.com | no. 1/2012

19

Programming

The Good, the Bad and the Ugly

Haskell

The Haskell code was compiled using “Glasgow Haskell Compilator” GHC 7.0.3 on Ubuntu Linux. It’s really easy to install using the command:

$sudo apt-get install haskell-platform

$sudo apt-get install geany

...and the editor I used was geany.

The resulting Haskell code has around 1200 characters on 45 lines.

To generate an executable the compiler needs the Main module containing a main function: module Main where import import import import

System.IO Data.List Data.String.Utils System.Directory

Next is function main which has the default type “IO()”. This means that main doesn’t return anything but it produces side effects of type IO. As you can see the function is a sequence of actions, chained by one of the operators >> or >>=. The difference between the two is the fact that >>= takes the result of the previous action and passes it to the next action in a pipeline fashion. So we can say that the main action is obtained by the sequence of the functions putStrLn, prompt, getLines, mapM_, putStrLn. Since these are actions i.e. they produce side effects, the operators >> and >>= combine the actions so that they are executed în the proper order.

Another interesting function called from main is getLines.

It takes zero parameters and returns a list of lines read from the standard input. It’s very important the fact that this function, like most of the Haskell functions, is lazy. This means it doesn’t wait for all the lines from stdin but instead it reads one line and passes it to the next function for processing. So getlines returns a lazy list of lines, each element in the list is produced only when somebody actually tries to read it.

Another thing to comment on is function mapM_. This is a function from the “map family” which takes an action and a list and it runs the action for each element in the list. The first parameter of mapM_ is the function process while the second element is the lazy list returned by getLines. main = putStrLn “Ctrl+C to exit” >> prompt >> getLines >>= mapM_ process >> putStrLn “”

Below is the function process defined as a composed func-

20

no. 1/2012 | www.todaysoftmag.com

tion. The syntax run.word.strip, is identical to the mathematical function composition and it means that strip is called with the input parameter, then words is called on the result of strip and after that run is called on the result of words.

Function process doesn’t have any declared type but, being a composed function, we can easily deduce its type. Its input parameters are the same as the function strip and it returns what function run returns. So process has a parameter of type string and doesn’t return anything because run has the type “IO ()” but it produces an IO side effect. So the signature of the function process is “process :: String -> IO ()”. Since I didn’t consider it necessary for understanding the function, I didn’t declare the type but the compiler didn’t complain about it and inferred the type correctly. process = run.words.strip

The function getLines is written almost the same as main.

The difference is the fact that function lines is pure, without side effects, and it is called with the result of an action getContents.

The function getContents is executed in the IO monad (since it has IO side effects) and its result can’t be passed to the function lines because it is outside the IO monad. For this reason lines is composed with the function return so that the resulting function is in the IO monad and can receive the result of getContents. getLines = getContents >>= (return.lines) prompt = putStr “>”

>> hFlush stdout

As you can see for function run I decided that the type signature would make the code easier to read. run :: [String] -> IO () run cmd = execute cmd >>= putStrLn >> prompt

The function joinLines receives a list of strings and returns a string. However, in the function implementation, there is no parameter declared. The reason is the fact that the function join takes two parameters. The first one is a string which is the separator and the second one is a list of strings to join using the given separator. If join is called with a single parameter, we obtain a function which waits for the second parameter and which will actually make the call to join. This is called currying. The code below reads as English: joinLines is joining strings by “\n” joinLines :: [String] -> String joinLines = join “\n”

Below is the function execute which takes a series of equations which cover various calling conditions. This is an alternative to the if instruction. If the parameter matches one of the three patterns, then the corresponding equation will be called. As you can see we have the following situations: when the first element in the list of parameters is “ls”, when the first element is “cat” and the

TODAY SOFTWARE MAGAZINE

other case. The last match is performed only if the first two failed. Thus, in this case, we have a bad command. execute execute execute execute

:: [String] -> IO String (“ls”:params) = ls params (“cat”:params) = cat params _other = return “Bad command”

The ls function is also defined by several equations. One for the case when it’s called with an empty list, one for the case when it’s called with a list containing one element and one for the case when the list contains more then one element.

Another thing here is the function “catch” which has two parameters: a function to execute and an exception handler. It executes the function and, if it throws an exception of type IOError, it executes the handler. In this case the handler is an anonymous function, aka lambda function. The syntax for lambda function is “\ param1, param2, ...,paramN -> code”. Since we don’t care what the exception is, we use _ for the exception handler parameter. ls :: [String] -> IO String ls [] = ls [“.”] ls [dir] = catch (getDirectoryContents dir >>= return.joinLines.sort) (\_ -> return $ “Could not read ‘” ++ dir ++ “’.”) ls (dir:extraParams) = return “Too many parameters.”

Since the function ‘cat’ is more complex we need to define a few local functions. These are defined in the where clause. The where block is defined by indentation. As you can see the inner functions can also have where blocks, with their own inner functions.

The inner functions have access to all the names defined in the parent namespace. Thus the function formatOutput has access to the parameter path from the parent function catOneFile. It could also access the parameters files from the grandparent function if needed. cat :: [String] -> IO String cat [] = return “No files to cat.” cat files = mapM catOneFile files >>= return.joinLines where catOneFile :: String -> IO String catOneFile path = catch (readFile path >>= return.formatOutput) (\_ -> return $ “Could not open file ‘” ++ path ++ “’.”) where formatOutput content = path ++ “:\n” ++ content

Closing

I expect the readers to send their opinions by email to ovidiu.deac@todaysoftwaremag.com, to comment and vote for each solution with one of these ratings: good, bad and ugly.

The next issue of the magazine will contain the results and we will solve a new problem. Proposals for problems, programming languages or alternative solutions are also welcomed.

www.todaysoftmag.com | no. 1/2012

21

Interview

Interview with the Finalist Team at Microsoft Imagine Cup

Marius Mornea Fost senior software developer in cadrul Nokia, în prezent fondatorul platformei Mintaka Research

22

no. 1/2012 | www.todaysoftmag.com

The “Interview” section of the first issue of our magazine has given us the opportunity of meeting and knowing better a team of young students from Cluj, national champions and international finalists at Microsoft Imagine Cup. Simplex is the name of the team, and its members are Alina Calin, Andrei Cantea, Andrei Dascalu, Cosmin Mihaiu and their mentor, Dr. Dan Suciu, Lecturer at the Chair of Computer Systems, Faculty of Mathematics and Computer Science, “Babes - Bolyai” University, Cluj-Napoca.

During two meetings we discussed what this competition meant, how they got to participate in it, what they accomplished, who supported them. They also shared with us some memorable moments, impressive meetings, the way they grew personally and professionally, all these things summing up in a wonderful experience. Furthermore, we had the chance to see a demonstration of their project and to discover their side of developers and entrepreneurs at the very beginning, determined to turn their initiative in a real product on the market. This article intends to briefly present Imagine Cup, the competition and the experience. Hereinafter, we shall insist more on details about the project, future plans and the evolution towards the business environment. If you want to find out more details, we invite you to watch the video interview at: www.todaysoftmag.ro.

Imagine Cup is the most important international student competition, hosted

by Microsoft, and its declared purpose is to: „Imagine a world where technology helps solve the toughest problems”. At its ninth edition, the competition impresses by its dimension: a total of 358,000 students, participants from 183 countries/regions, out of which over 400 finalists from 70 countries.

Romania is a traditional presence and last year it ranked 5th worldwide, with more than 800 participants, divided into sections: 120 participants (IT Challenge); 3 teams (Digital Media); 4 teams (Embedded Development); 3 team (Windows Phone 7); 3 teams (Game Design). It was not only the number, but also the last years’ performances that recommended the Romanian teams for the 2011 edition: Software Design - Sytech team – Gold in 2009; IT Challenge - Cosmin Ilie: Bronze in 2007, Silver in 2008 and Gold in 2009, Valy Greavu – Silver in 2006; Embedded Development - Aether team – Silver in 2007. And the teams confirmed with Bronze – Endeavour Design (Embedded Development), Gold - M.N.A team (Digital Media) and a place among the first 6 finalists in the last round of Software Design, the main section of the competition, for Simplex team.

The constant presence and performances are due to the excellent promotion, nationally made by Microsoft through the academic program, to the support of the mentors inside the universities and first of all to the high level of quality imposed by the participant teams. As the members of Simplex also declared, “the local competi-

TODAY SOFTWARE MAGAZINE

tion had been well organized […] and many teams were encouraged to participate” (Andrei Cantea), “the national round imposed quite a high standard” (Andrei Dascalu), “the team from the second position was probably even better than other teams from the world competition” (Andrei Cantea), the jury’s constant feedback and the mentor’s help, who helped them “not to take all the wrong decisions”(Cosmin Mihaiu), they build an atmosphere which stimulates performance and quality, ingredients for certain future success.

“The success which deserves all the given effort”, the members of Simplex team assure us, who enthusiastically tell some of the memorable moments of their experience. Starting with landing in New York and accommodation at Marriott Hotel in Times Square (all logistics details had been taken care of by Microsoft), till meeting Steve Balmer (CEO Microsoft), to whom the four members had the chance to make a personal demonstration of the project, the interaction with other great names in the industry (Jonathan Perera, former GM Microsoft, at present VP Adobe), dinner and limo ride accompanied by other two VPs Microsoft, as well as material rewards ( one Windows Phone 7 each and one BizSpark license intended to support start-ups with all necessary Microsoft products) or the money prizes of $25,000, $15,000 and $5,000 for 1st, 2nd, 3rd places. An experience rich in feelings and unique memories, which helped them grow a lot individually, as well as a team.

Nevertheless, Imagine Cup experience does not end with the competition. On the contrary, it seems to be only the first step.

Let’s have a closer look to the application and the next steps:

we used Kinect, a device from Microsoft, which was new at that time, to involve the user, actually the patient, in easy but recovery-meant games.” Cosmin Mihaiu „Actually, MIRA is made of two parts, one designed for the doctor and the other for the recovering patients. The doctor’s benefits with this application are: patient management, schedule management and, the most important one, the statistics which allow him to follow the patient evolution.

When the patient comes for recovery, the doctor starts an application and the patient is playing with it, but at the same time he is engaged in recovery exercises. The patient might not even notice but every movement is stored and thus, the doctor can see the evolution” Andrei Dascălu

What is MIRA? With „Medical Interactive Recovery Assistant” we want to help any person suffering from a temporary locomotory handicap, persons who, for example, have suffered from a stroke, the fracture of a hand or limb, to get through recovery time, the period of regaining reflexes and movements which used to be very simple, in an easier and more interactive way. In order to that,

„We have decided to give it a try, to see what comes up. At the moment we are working on the first version, to enter the clinical testing phase in order to see what the impact of the application upon patients is, to see from the statistics whether there really is an evolution in their recovery. If we are successful, we go on. If not, we’ll take another road. […] Of course, we continue to be motivated, especially as, two weeks

As the competition is over, what are your future plans with the application?

There are some alternatives as a career plan: to start on your own (establish a company), to get a job at one of the software companies in Cluj, to go abroad and, with Imagine Cup on your resume, you might do that…So, what would be your choice? „The question arose during the worldwide final, […] what to do next? We were accompanied by Mr. Dan Suciu, our mentor, and some other persons, and this topic has come up: we can get a job now, work in a company for a couple of years, see how things go, and then, if we don’t like it, we can get together and start our own business ... or the second choice, to start a startup, develop our product, launch it on the market, see what happens. Most of the people told us: “You are young; you can afford to take the risk, meaning this is your time to risk, you have nothing to lose” Cosmin Mihaiu

ago, we tested the application for a couple of days in a hospital in Bucharest and we were really motivated to see many kids playing and being happy” Andrei Dascălu You have been mentioning the clinical testing. It is necessary to get a validation from the doctors in order to prove that the process is effective. What is the feedback so far? „The feedback is positive; […] all the doctors or kineto-therapists have given us a positive feedback and told us we are on the right track. […] all were nicely surprised and told us what they need, what to do more. Microsoft Romania has not forgotten about us after the national round and they are offering support. Thanks to them, we have started our cooperation with the recovery centre in Bucharest. Our chance is that a doctor working there, Adrian Oprea, is very enthusiast about our solution and he’s helping up. He wants us to be successful, that’s why we are discussing and working together. As we already have a person that is helping us, we don’t want to go to more hospitals, as we might get too much feedback and do nothing.” Cosmin Mihaiu „Let’s not forget that Microsoft gave the hospital a laptop and a Kinect device.

We installed our program on that device and they are supposed to start the recovery.”

Andrei Dascălu I know that many winners had the opportunity of presenting their solutions to the President, the European Parliament and other institutions, I was wondering if you participated in press conferences or other similar occasions? „Immediately after we came back from Imagine Cup, we were contacted by the Romanian press. We had TV appearances at ProTV and TVR. At the beginning of December, Microsoft Romania held a press conference about “Competition in IT”.

Politicians and Government employees also participated at this conference and there were a lot of discussions about competition in the Romanian IT. We represent a practical application, a proof of the fact that there are software ideas from Romania, not coming from abroad. ” Cosmin Mihaiu.

www.todaysoftmag.com | no. 1/2012

23

Interview

When do you plan to have a release? „The moment we are confident of reaching a product that can really help in recovery in hospitals […] in autumn to be able to enter the market.” Cosmin Mihaiu The experience sounds good, so is the subsequent development. It seems you have found a preoccupation for the next years […] do you have any advice for the students following you, the future generations? „It’s worth it! Yes! Definitely! This time last year we knew we wanted to participate, not necessarily manage to have a product and believe 100% it would help a lot of people, but we wanted to get to.”

Cosmin Mihaiu „To have something in our history as students, to prevent anyone from believing we did nothing during our university years.

We have decided to give it a try.” Andrei Dascălu „Exactly! And during the application development, the same happened with Caregamer, you end believing in it…believe that your application can have an impact.

Later on the purpose has changed, to get to launch the product on the market.” Cosmin Mihaiu Besides the fact that it’s worth it, can we help them with any advice? Which are the abilities you developed in between or used the most during the completion? „Participating at Imagine Cup they can learn what team and competition are really about, how a presentation looks like, they can discover all kinds of development environments to use in the future, in their career. The whole competition teaches you how to believe in your own ideas and it motivates you to put them to practice.” Andrei Dascălu „By definition, Imagine Cup is a contest which develops all your abilities: teamwork, presentation skills, time management. Time is definitely the biggest enemy during the contest. You never succeed in developing the application upon time and as you want it. Therefore, you have to start managing priorities in such a way as to be

24

no. 1/2012 | www.todaysoftmag.com

Interview with the Finalist Team at Microsoft Imagine Cup

on time for every deadline. […] You end up thinking in terms of business, as, after all, you have to present your idea in front of people who know how business is done, both from an IT and a startup point of view.

So you end up working on all levels.” Cosmin Mihaiu What are the three most important things they need to pay attention to or to prepare the best? „I place time on the third position, somehow you have to manage it in order to impose all things and get through them on time. It is compulsory to believe in the application. If one member fails to believe in it, the whole team might fail. Everybody should work as a team. It’s like in a fourwheel car, if one wheel is missing…it’s in vain.” Cosmin Mihaiu „The presentation has the biggest influence on the jury, 80% of the score.” Andrei Dascălu „It’s weird and unfair in a certain way that, as the product is a technical one, the jury is not technical all the time. If you are too detailed in algorithms, you might not impress them. Your presentation needs to be very well done.” Andrei Cantea What brought you together as a team? „The fact that we are so different. Every one of us is good in his domain and I think…as a matter of fact I know not a single major decision was made without consulting the others. We worked as a team and we continue to do it as it proved successful so far and there is no need in abandoning it.” Cosmin Mihaiu This is Imagine Cup after all, teams that get together and can develop other successful applications in the future. Let’s hope so!” Andrei Dascălu Finally, Imagine Cup is the perfect opportunity to meet the business world, build up a team and learn how to carry through a project that you believe in and that you have the chance to present in front of some big industry names. More than that, after the interview, we found out from the competition blog that Microsoft launches Imagine Cup Grants. With a budget of 3 million dollars for the next three years, it plans to fi-

nancially support startups from among the finalist projects. Four teams have already been awarded the grant and had the chance to present their projects during a meeting with Bill Gates and Brad Smith. This is the reason why we recommend all the students to get advantage of this opportunity. Imagine Cup has proved to be a wonderful experience, as well as an IT career and business environment launching platform.

TODAY SOFTWARE MAGAZINE

www.todaysoftmag.com | no. 1/2012

25

Startups

StartUp Mintaka Research

Marius Mornea Fost senior software developer in cadrul Nokia, ĂŽn prezent fondatorul platformei Mintaka Research

26

no. 1/2012 | www.todaysoftmag.com

Researchers are often perceived as lonely individuals spending their whole lives closed in laboratories and working with complicated instruments or formulas. However a little research will prove that most famous researchers collaborated, interacted and debated with their peers and were public figures frequently. Even Albert Einstein, thought by many to simply have appeared out of the blue and completely revolutionized Physics, gathered Maurice Solovine, a Romanian student, and Conrad Habicht, a Swiss mathematician, to form Olympia Academy, an informal group that had regular meeting and discussed latest scientific discoveries, own work and even philosophy and literature two years before his â&#x20AC;&#x153;miracle yearâ&#x20AC;?. Innovation and discoveries come as much from dedicated solitary work, as from collaborative research and exchange of ideas and findings.

This is the core philosophy of our initiative: a Collaborative Research Platform and Services Center. Our mission is to bring together Research, Business and Education in a single collaborative platform and offer services that enable cooperation, building trust and relationships among the three, by creating a pool of competences and a set of tools for working together.

Our main goal is to create a strong research community that shares its knowledge with both education and business, thus ensuring both continuity and new opportunities to bring the latest innovations closer into our daily lives. The core philosophy is to promote collaborative effort, as opposed to individual research, aided by a set of tools and services that will enable tackling more difficult challenges and creating extra value. To better understand the concept we will take a closer look at the ideas and context that brought about its birth.

The first idea started off from a very frequent need found in the business environment: the need for specialists. A resource that usually raises certain management challenges: foremost the high financial costs and the extended period needed for training or recruiting (in cases where the local job market lacks the needed resource); secondly the fluctuating engagement level (in general the specialists are needed in the conception and architecture phases, or for performance and optimization purposes), periods of high engagement alternating with those of low activity. This leads to two commonly preferred approaches: hiring/training a specialist engaged at full capacity for short periods of time and assigned on routine tasks for the rest; or delegating the role of specialist to one member of the team, which usually leads to delays, poor performance and drops in quality. A third solution, less encountered on our local market, is the involvement of specialists in consulting services, leading to a convenient resolution of the above challenges, both from the employer and employee perspective. Without starting a debate, we assume that the lack of consulting services is a consequence of a relatively low market maturity level and more im-

TODAY SOFTWARE MAGAZINE

portantly the predominant outsourcing nature of the local IT environment. Both lead to a sensible shortage of specialists on the job market, either due to blocking them in low visibility fixed positions, or due to the exodus towards more mature markets with constant expert level engagement demand.

This is the context that gave birth to the first idea: creating a structure that would allow identifying and increasing the mobility of the local market specialists. The idea has evolved further into two concrete solutions: creating a specialists community to enable their localization, and creating a framework that would encourage mobility and ensure a stable and sufficient engagement level.

The first solution has already proven feasible by similar local initiatives like: TJUG (Transylvania Java User Group), GTUG Cluj-Napoca (Google Technologies User Group), RTC (Romanian Testing Community), AgileWorks Romania, Semantic Web meet up group, Today Software Magazine etc. It’s also worth mentioning the initiatives unrelated to ITC, like the two locally founded TEDx organizations. All of the above have confirmed the need and openness towards the creation of communities promoting collaboration and specialist level knowledge sharing, in order to grow the innovation and quality on the local market.

The second solution proves to be more challenging due to a lack of constant demand for high level competences. The fluctuating workload leads to big variations in income, but also in difficulties with keeping pace with the fast evolving technologies and skills demanded by expert level consulting services. In plain terms, we need to find a way of filling empty time slots between projects, with meaningful and challenging work. Our proposal is active involvement in research projects, and to support our claims we will detail the context and our second idea below.

In the last decade we have seen extraordinary developments in Romania’s research environment, from the initial revival attempts through signing the Barcelona 2002 European common research strategy treaty, followed by formalizing efforts to ensure a uniform framework approach at

Lisbon in 2005, with clear positive effects on local level in 2007-2008, to drastic cuts imposed by the global economic crisis and bureaucratic changes that render most of the funding unreachable. The initial European alignment efforts gave birth to an entire generation of Romanian researchers with real results, high levels of specialization and international contracts. However, most of them were concentrated in the government funded public education system, with a high degree of dependency between research, education and the political environment. Private research initiatives hold a very low percentage, European statistics showing the following research funding evolution in 2008, by source: business 45.4%→23.3%, government 47.6%→70.1%, foreign 5.5%→4.0%. This means that the remaining specialists on the local market are stuck in an environment, which through its hybrid nature research/education, denies clear, dedicated focus on research, most of the times both activities suffer drops in quality, but also through its excessive bureaucracy decreases mobility, tying research specialists to the education and government system. Even so, a few local private initiatives like Coneural, RIST (Romanian Institute of Technology), Ad Astra and others try to offer an alternative which through lack of bureaucracy, politics and separation from the educational system, allows exclusive focus on research and achievement of maximum potential.

This context gives birth to the second idea: creating a private research center that would offer a proper research environment, separated from the state system, allowing and encouraging researchers from academic fields and specialists from private sector to collaborate on projects that would fill the gaps between consulting projects. The main role of the center is attracting projects and funding, from several sources like: business, European and government environments, allowing project based collaboration and promoting a shift in mentality towards a more mobile and asserted consulting community of specialists.

The last idea is tied to education and its role in ensuring continuity. Seeing that the first two concepts are mainly concerned

with identifying and engaging existing specialists, the last concept looks towards the future and towards the possibility that the current local competences cannot cover the market demand, both in range and volume. This renders clear the need for active involvement in the educational process through knowledge sharing between market specialists, academic researchers, and educators in an effort to enrich the academic environment with extracurricular activities, or even ways to align the current teaching curricula to the needs of the business environment. Thus we will support business experts collaboration with academia, aiming to increase the quality of the didactic material, but also to raise the interest and motivation of the younger generation, resulting in higher involvement and better performance. In practice, there are others who have successfully achieved this, for example Austrian Hagenberg institute and Chinese based Neusoft IT Company, both have gone one step further, by creating their own education facilities with an active role in creating specialists tailored to their specific needs. Supporting the education system combined with the two ideas above, defines the context in which our initiative began to take form and after several refinement iterations, evolved into the collaborative, cross-domain research platform.

Now let’s take a closer look at the customer value proposition and then map the benefits offered to our customers to the products and services our organization provides. The benefits are divided in three main categories that result from the target groups: Research, Business and Education that our organization intends to bring together for collaboration.

The Platform

In practice, in order to support the community and cater to the needs of such a heterogeneous target, we will offer an online platform that holds together a set of tools and services divided mainly in four categories: community, communication channels, knowledge repository and scientometrics. Content will be split in: general and user based authentication accessible content. Each category will be detailed in www.todaysoftmag.com | no. 1/2012

27

Startups

the following paragraphs and it will show how it provides the benefits to each type of customer.

The Community This business component will handle all community related services and interactions. The main building block of the community section will be the competences pool: a centralized database of all competences accessible through the platform.

The database will be built by aggregating information from all registered collaborators profiles, ranging from individual researchers to teams and organizations. Competences will be grouped based on several criteria: research (domain, technology, fundamental, applied), development (domain, technologies, workload capacity), communications (channels, audience), business (financing, HR), etc.

The Usage Model: each user can browse the competences pool. Helped by a tool, he will be able to build a generic competences team which will collaborate to achieve a goal. If the community offers all needed competences and the goal is reachable, the user can finalize the team by providing a clear specification of the goal and submitting it to the community. All available users with competences that map to the newly created team will be notified by the system and can respond if they are willing to collaborate or not. When all needed positions are filled, the initiator of the project and the collaborators will need to sign a terms and conditions document and then they will all see their specific contact details and can start working together.

This generic collaboration model allows a very wide range of interactions and maximizing the involvement of all resources in order to reach all the paths described in the CVP Venn diagram.

The Knowledge Repository This is the business component that stores and provides knowledge artifacts to the community and outside customers.

While content in the repository may be generated either by the crowd or internally, it shares the common trait of being under the IP of Mintaka Research. Content will be

28

no. 1/2012 | www.todaysoftmag.com

StartUp Mintaka Research

organized in different categories as: papers, prototypes, processes, methodologies, patents, trainings etc. Several access levels will be granted, ranging from freely accessible, even open source, to paid, or even restricted internal access only. Here is an example of the internally developed content: a complete glossary of research methodologies and a collection of technology management techniques and processes. These are one of the core strategic strengths our organization intends to invest in.

The knowledge repository is not a purpose in itself, and even though its building is a continuous process, once a critical mass is reached, a separate process of capitalizing on the content will start. This will be done in two main processes: on one hand by providing trainings and knowledge transfer consulting and secondly by searching for applications in the industry that could give birth to new ventures or partnerships. Together the two processes will join efforts to apply the knowledge in the repository back in the business environment.

Scientometrics As the name implies, this component will be responsible for measuring and analyzing all scientific endeavors. From simple free peer reviews, to industry wide results comparison and benchmark, impact analysis, metrics and bibliometrics. Again the range of services will be split based on provider (community, platform, external services) and on level of prestige (internal, local universities, national, international evaluation), which in turn will impose the pricing range.

The model here has two main flows: first a substantial free offering intended to guarantee a high level of quality and constantly improve the community, both at individual and collective level; secondly a high standards offer of best services with objective metrics and benchmarks, for the demanding projects and challenges intended to capitalize on large and high profile requests.

Two important partners in the sciento-

metrics effort will be the CENAPOSS governmental center and Ad Astra non-profit association, which already have national efforts in this direction.

The Research Team

Besides the community building efforts and the platform and services offering, we intend to create a research team with main interest in Autonomic Computing. This will enable us to be a contributing member of the community, to field test our platform and service offerings. It will act as an income source as well.

Besides the research itself, this branch of the business also adheres to the more general philosophy of promoting and building higher standards for the local research community and it does so by offering an independent environment dedicated to the research itself. We believe that research should have the opportunity to take place clearly separated of the educational institutions, gaining focus and freedom from the overly bureaucratic ways of the state system. It also creates a competitive ecosystem in which success relies on the quality of the research and attractiveness to different funding sources, removing the dependence on the government budget, policies and politics.

To conclude, our approach is to create a software platform that offers members the possibility to: - create project teams from a wide selection of cross domain competences, - use communications channels with government institutions, EU FP7 programs and business partners to access funding - benefit from continuous support throughout their project lifetime in any of the fields: Technology Management, Research Methodologies, IP Management - get practical help such as: peers reviews, benchmark of results, emergency staffing from the community etc - contact the international associations like IEEE , ACM, RSA to make their research visible and share it with other people.

TODAY SOFTWARE MAGAZINE

Once the platform is operational we will start giving back through: - Partnerships with local businesses to apply the latest technologies back in the community to improve the way of life - Partnerships with educational system to improve the quality of the teaching process, enrich curricula and motivate students, thus insuring continuity - Partnerships with cross-domain researchers to bridge the existing communication gaps and create value and new opportunities by combining and complementing our competences The current political and economical context, both national and international, recognizes the need for quality research and supports initiatives that promote collaborative efforts to innovate and create new jobs

in the business environment. However, on a local level, there is currently a communication gap between the research, education and business communities, which prevents collaborative efforts that can bring added value. Addressing this gap can lead to both individual growth for each involved party, but also to new types of interaction and novel projects that allows joint growth. With a steadily maturing local business community and the historically strong university center that houses two out of the four national, recently ARACIS certified universities, the future perspectives of collaboration look promising and we are confident that we will find the partners and resources needed to succeed.

www.todaysoftmag.com | no. 1/2012

29

Management

From one idea to a product We all have innovative ideas about how to make the world around us better and how we can draw some benefits of it. Unfortunately, there is a long way to go from the initial idea to the launch of a product or service on the market. This series of articles will focus on how to be efficient. The main target is represented by small companies wanting to launch a product or even individuals who want to start a business. We won’t cover all the stages and approvals that take place in a multinational company. Our goal is to simplify the process and to adapt it to the practical needs. We start our series with an example from the present days: the social networks.

The Initial Idea

Creating a social network where people from our neighborhood publish services, events or sell things. They will be able to know their neighbors better, to be informed and take part in the community events. They will create a better connection with the local authorities as well.

Ovidiu Măţan, PMP Coordonates Gemini Solutions Cluj’s team, in the past worked as a Product Manager for Ovi Sync at Nokia, founder of Today Software Magazine.

30

no. 1/2012 | www.todaysoftmag.com

Summary Here is the list of processes to be applied, with the remark that sometimes some of the processes interpenetrate.

The company’s vision - - It is the development vision of the company, according to which the company’s strategy is defined.

Business case - It’s the Investment Justification document. It is compulsory to approve this document before passing to the next steps.

Market requirements (MRD) - - It contains marketing elements to promote the product: advertising plan, promotionals and product distribution strategy on various channels.

Use cases – Defining the way the product interacts with the users and the operating steps Features matrix - It’s the capability matrix of the product. It’s very useful in comparing the product with other different products and its positioning.

Product roadmap - – It’s the short-term (1 year) and long-term (5 years) product development plan. Depending on the market changes, users’ preferences or any other internal/external pressures, it will suffer alterations which are to reflect the new state of things. It serves as a background image of the possible product evolution in the next period.

Product requirements (PRD) - Based on Market Requirements (MRD) and considering the defined use-cases, it sets the product’s requirements, establishes the framework the product will function in, the expectations regarding its performance, scalability

TODAY SOFTWARE MAGAZINE

and security. It represents the basic specifications the development team will build upon during product implementation.

Product Positioning - Positioning the product on a market considering the existing offer and features matrix.

Pricing model - Defining the product’s price according to its positioning Launch plan - The plan of the product’s release on the market Development of new products - The way we plan the next products’ release, taking advantage of the previous product market, the existing skills and competences.

The Vision

Creating new products and services makes sense as long as one knows where he wants to get to. A product development strategy makes sense if it follows the company’s vision. This vision must consider the technology and market evolution. For example, until iPhone’s launch, Nokia was the leader in mobile phones and smartphones. Their vision didn’t include touch interaction with the phone screen. This was made with the help of a pen. iPhone launch in the early 2007 and its great success have changed the market. It took Nokia a few years to react, which made them noncompetitive on the smartphones market. In order to get back on the market, they made huge sacrifices such as abandoning the development of Symbian Operating System and the transition to Windows Mobile.

A frequent mistake is the confusion between vision and strategy. The strategy is defined according to the company’s vision.

Here are the main strategies in defining the vision: 1. 20/20 Vision - The term comes from the visual acuity test (http:// www.allaboutvision. com/eye-test/) based on Doctor Hermann Snellen’s chart from 1860 and it consists in reading it from 20 feet / 6 meters. For an IT company, this vision means that the steps to be made in order to reach the current stage are extremely clear and there is a very good understanding of the technological evolution and the opportunities on the market.

2. The Peripheral Vision - The Company is especially interested in the trends around it and new opportunities, much more than any other companies. In 1970-1980, Wang Laboratories were making desktop computers for test processing. Their lack of peripheral vision made them go bankrupt in the 90’s because they ignored the PC trend created by IBM. 3. The Clairvoyance - It’s the capacity of identifying future opportunities, not seen by the competition. The examples are Apple’s iPhone/iPad and Bill Gates’ vision in creating software for PCs’.

In creating successful products, the company’s vision needs to have focus, to be clear, complete and implementable. There are 3 questions that need to get an answer: 1. Where do we want to go?

2. How are we going to get there?

3. Why are we going to be successful?

Coming back to our example, this is how vision is defined: We acknowledge the social networks’ evolution and through our products we’ll create a communication ecosystem designed for local communities. We’ll use our present knowledge to create products accessible to anyone. The social networks will get a new meaning, integrating the real life into the virtual one.

Business Case

This document is the background of our project, it defines the new product and it will be used as reference for future documents. A document and a presentation for approval stage of the project will be put into practice.

According to PMBOK, the business case is the document with the necessary information for the investment decision in this project. Normally, it contains a cost-benefit analysis for project motivation. In the end, everything is reduced to potential profit analysis, considering the risks involved in implementing, selling and maintaining the product. The Business Case is the result of one or more of the following requirements: • Market requirement • Organizational needs • Client request

• • • •

Technological advance Legal requests Ecological impact Social needs

The business case is periodically revised in order to check that the project keeps following the initial goal. It will be also checked whether the final product or service is still necessary. It is wrong to consider that, once it is finished, the business case is put on a shelf.

Another document which can be created before starting the project is the Statement of Work (SOW). It describes the products and services to be delivered. In case the implementation is done by another company, the document can be used as legal background for all the services to be delivered.

In practice, the contract and SOW are the main documents, according to which starting working on a project is agreed.

Coming back to the business case, it is recommended to use a template when writing it and if available, a business case for another approved project of the company. A very good example can be found at http://www.blackblot.com/files/pmtk/ Blackblot_PMTK_Evaluation_40/PMTK/ PMTK_Product_Marketing/Business_Case/ PMTK_Business_Case_40.pdf Simplifying the pattern structure, it is recommended to accept the following aspects: • Executive summary – it contains the starting date of the project, the main stakeholders to benefit from the project, the total costs and short-term costs (6 months), the completion date of the project • Project description and adaptation to the wide technological framework and present market • Goal - Clear definition of the project goal by underlining 3 of the most important aspects • Short and long-term objectives • Return of Investment (ROI) – internal/ external benefits of project implementation • Project implementation including the resources to be used • Implementation cost (see example) • Implementation cost (see example) www.todaysoftmag.com | no. 1/2012

31

Management

• •

Risk analysis Next steps to be followed after project approval

Backup material – contains all project details that haven’t been presented in the main document. It can have detailed information about project costs in order to demonstrate the choice of a particular service provider, working method, details about project’s milestones, means of communication during the project, project status publishing etc.

Many of the above items can be the subject of a new article such as Accurate estimation of a project duration, Risk analysis, Market analysis, Working methods during a

32

no. 1/2012 | www.todaysoftmag.com

From one idea to a product

project and Short and long term goal assignation.

The example of a business case will be analyzed in our next issue. I encourage you to write a business case for our example which will be presented in the next article.

You may send the business cases to ovidiu. matan@todaysoftmag.com

TODAY SOFTWARE MAGAZINE HR

Creative compensation

Ioana Fane HR Specialist Ullink Cluj Napoca

The basic concept of the compensation management is quite simple: employees perform duties for their employers and companies pay salaries according to the fulfilled objectives. Therefore, compensation is an exchange or a transaction from which both parties - employer and employee - can benefit: both sides receive something for offering another thing. However, the benefits involve much more than a simple transaction. From the employer’s point of view, compensation is a matter of accessibility and motivation of the employees.

The crisis period began in early 2009, when most IT companies made the transition from providing a more attractive fixed salary, to developing and establishing more appealing compensation and benefits packages, in order to attract the external resources market, but also designed to maintain current employees motivated.

These packages - which are often the best pick of any human resources specialist, should tailor the employee’s personal needs and then they should be implemented according to the budget provided by the company’s management.

The compensation and benefits package is that transparent and more visible topic when it comes to a job offer and not just because it hints towards a non - financial benefit, but also because of the economic stagnation forecast and thus wages.

From the companies perspective it is more convenient and cheaper to try retaining the employees within the company and to try adapting the motivation policies according to their needs, instead of hiring and training other new employees.

In determining policies of benefits and motivation for employees, companies are considering several reference points:

• • • • • •

Benefits packages offered by similar companies for their employees The amount of benefits offered on the market value Total number of employees Share on hierarchical levels Tax allowances The average age within the company

There are several ways to measure success of an entrepreneur: the number of new launched ideas, revenues and profits, and the way he or she serves an industry or community. But perhaps the most important of all these is the impact that the entrepreneur can exercise over the lives of the employees. Beyond the tangible rewards such as pay and intangibles such as counseling, a manager can really influence the life of an employee, by providing a generous package of benefits. Indeed, many entrepreneurs admit that the effect they have on an employee’s life is one of the most rewarding aspects.

It also has the potential to keep us awake at night. This is because, in order

www.todaysoftmag.com | no. 1/2012

33

HR

to provide generous benefits, a rigorous financial planning should be put in practice.

Most compensation and benefits packages are not cheap and costs can increase exponentially when the company expands.

In addition, once the company provides a benefit, it is not wisely to cancel it once the economy declines.

To put it otherwise, if a company becomes popular in the IT&C field by offering attractive benefits, recruitment of talented employees becomes easier and positive side effects on the marketing and sales areas may be visible.

How to negotiate your best compensation package?

All aspects of each job offer are negotiable. Negotiating salary and other benefits is a vital skill that all successful IT professionals must possess. The key to successful negotiation is that you must understand the priorities, needs and then to be linked to the employer’s needs.

The IT&C sector implies a huge gap between demand on high specialized resources and the quality & quantity of specialized people offered by the Romanian education system. Therefore, wages are well above other industries on the Romanian market and packages are daring and try to banish any hint of dissatisfaction from an employee, and to create a modern and relaxing way of living.

Small companies offer more generous compensation packages than large companies or multinationals. Lack of brand notoriety on the market and of a rigorous system in developing salary and benefits packages enables them to be more flexible and attractive for the recruitment market. On the other hand, the benefits package in IT companies are the most creative and generous.

While salary and benefits packages are becoming more complex, employee performance and potential candidates work results are decreasing. This happens because of high staff turnover, which lowers individual and organizational performance but also the employees opportunity to specialize.

It is known that the minimum time in which an employee performs at an optimal level is one year. Many IT experts are pay-

34

no. 1/2012 | www.todaysoftmag.com

Creative compensation

ing attention to new offers and jobs immediately after this period.

Some companies decide to keep the remuneration below market average wage level and decide to hire young people, who accept lower wages than market level, but they are convinced that the trainings offered by senior staff or certificates supported by the company, will enable them to start a great career and will soon become candidates that all companies are searching for. Positioning the wage above the average market will determine the HR department to focus on experienced candidates who have promising results early in employment.

The question remains how compensation would minimize the disproportion between old employees in the company, who developed slowly, and newcomers who are paid at the current market level. It is well known that when wage negotiations and evaluations are elaborated, managers do not take into account the local or national market, but wage levels within the company. A brief analysis of costs shows that the turnover of staff implies tripled costs: the cost of recruitment, the loss of productivity and the specialization and training for the new employees.

We must admit that the benefits provided by companies to motivate their employees are on the other hand, personnel management tools of interest to the employer.

Here are some examples of benefits for employees provided by IT & C companies in Romania: • meal tickets - tools of motivation, in other form than cash, which are tax exempt; • vacation bonuses - which can range from half to full salary; • holiday bonuses (Easter and Christmas holidays) - which can vary between 0.25% and 100% of the net salary; • the 13th salary - paid before the New Year holidays; • child birth bonus - for all employees at the birth of a child or, for unfortunate cases, the death of a relative; • medical care insurance for employees - the amount of insurance can vary depending on the employee’s hierarchical position; • medical insurance for family mem-

bers;

• dental insurance services - in this case the amount may also vary depending on the employee’s hierarchical position; • optional retirement policy; • life insurance; • subscriptions to sports and leisure centers • phone and SIM card - they are considered benefits to the extent that exceeds the amount necessary to achieve limit assigned duties - otherwise it is only a tool • flexible work schedule - usually offered to those employees occupying managerial positions rather evaluated according to results, not according to time actually spent in the office; Compensation and benefits packages are depending on business structure, recruiting, retention, motivation, performance feedback and satisfaction at the workplace. Compensation is usually among the first thing potential employees consider when looking for a new job.

Finally, employees, compensation and benefits package is a reflection of not only how they are paid but also of the manner, in which they are evaluated by the employer.

Management

5 Differences between a Leader and a Boss I’ve met all kinds of line managers, operations managers, project managers, general and executive managers in different circumstances and various organizations. But only some of them spread around them a special relational flavor, an attractive and motivating one, that made their presence desirable. I would like to tell you a few habits a leader has that are not usually found in a boss (a manager just by profession):

1. The leader introduces himself as part of the team

Aristotel Dascăl, PMP Motivational speaker.

Spiritual explorer.

There are a few expressions that I’m sure you’ve heard, which in a more direct or subtle way emphasize a differentiation between a boss and a team member. A way to point out who is in charge in an organization. Generally these expressions draw a line between the boss and the team, the boss being the one that comes with the requirements and the team executing rigorously. Phrases like: „You need to mind your own business”, „For now I’m in charge so you do as I say” create a rupture between the manager and the team. The leader, on the other hand, approaches the project as a team effort that he is part of, with every member having his own role. He encourages people to have suggestions and express opinions towards anyone’s work, including his. The same treatment and rules are being applied to him as to each team member. Sometimes, even the way a boss expresses his appreciations emphasizes the boss-team member rupture, by making some feel they work for the manager, not for something great in purpose. A leader shows his apreciation in order to emphasize that the success is equally the result of each member, including the manager. So instead of saying „Thanks for doing a great job”, a leader is part of the team: „ I’m happy that together we achieved our goal.” Do you feel the subtle difference?

2. A leader practices authentic listening

Has it ever happened to you to feel that the personal evaluations or professional development meetings are simple formalities? A leader listens carefully and takes notes on your input, desires, dreams, asking questions for clarification, and together with you he initiates a development plan. Furthermore, due to the desire of growing his team, he regularly asks about the progress on your development commitments.

He offers you the time and resources he has to help you. A boss only nods when you talk to him, waiting for a pause to tell you his great ideas. At any of your approach he considers inappropriate he corrects you by saying: “But you don’t have to see it that way”, “Feel that way”, “It’s your fault”, “You’re the one who has to do more, and be proactive”. Although most are good suggestions, this is a reactive approach that holds a person back, makes him feel rather accused than encouraged. The leader

36

no. 1/2012 | www.todaysoftmag.com

TODAY SOFTWARE MAGAZINE

says “Give me some examples so I can understand you better”, “Let’s work on a plan together”. The boss says “Do a list with what you think it needs to be changed to yourself and come back later”. The leader is empathic, coming next to you at your own custom level. The boss loves to hear him giving solutions like pills.

3. The leader gives before he requests

A boss can request officially for some activities to be completed, with no relationship with the team. But a leader is aware that the people he leads need motivation, and according to Maslow, in the upper side of the personal needs hierarchy, there is “self-esteem”, and right on top of all there is “self-actualization”. In other words the leader is constantly concerned with understanding and satisfying the individual personal needs, he offers support and really lis-

tens before asking for the commitment and engagement of the team.

4. The leader is not threatened by the success of others

The leader has a realistic self-image and strong self-esteem. He does not identify himself through his professional position, but through his abilities and their effectiveness. That’s why he doesn’t hesitate to do the “low” activities that usually the team members do. Actually the leader considers this the key to his leadership influence: being side by side with the team, during everyday work and increasing the leadership skills in the team members that value this or have leadership skills without realizing it. The leader encourages your visibility increase in the organization and he becomes the advocate of your potential success. Bosses are often scared that, by growing, you will steal their place, but the leader knows that

his particularities will always find the right place. That’s why he engages proactively in your development due to ethics, for your sake and the organization’s benefit.

5. The leader has followers because the followers choose to follow him

The most obvious way to recognize a leader is his team following him by instinct. They quote him, confirm his ideas and values in discussions even if the leader is not present. A boss maintains a tense and cold atmosphere where people talk only if forced, and most often they talk bad about the boss when not present. You can follow enthusiastically only a vision that you share, that fulfills you and increases your value.

Only a leader can inspire his team like this.

“There’s only one person on Earth that can use your abilities” (Zig Ziglar)

www.todaysoftmag.com | no. 1/2012

37

Philosophy

10 vs. 1700 Presto - Allegro ma non troppo

Aurel Popârţac Software engineer, owner of an IT business

38

no. 1/2012 | www.todaysoftmag.com

As I was working in a far away land, over a sea and 5 countries, I started meditating on the matter in question – please sit quietly and relax! The work object was, in a pretty direct way, distribution of online services suite wildly used by my “suffer buddies” on the planet. I am talking about Google, Facebook, Twitter, Youtube, Picasa, Skype and too many others. Hence, the matter in question is the human ability of continuously staying, above all from an emotional point of view, under the frantic informational cascade.

Working closely with a group of handpicked “technicians”, we did the undoable and we “innovated” it a little bit – which is one of the main requests. Innovation means that, after a lot of thinking and not so hard planning, we developed a pertinent, I would say, operating system for smartphones.

The software was classically installed on touch screen devices and placed on the market. The masterpiece was and still is gifted with a set of applications meant for comunicating with and informing the others. Let this not be a vain boast and continue the story, here is what novelty was all about.

Beside the construction of specific applications for every above mentioned service providers, we integrated the simple line particular to such a system – Phone, Messaging, Photo/Video Gallery – with the services offered by the providers. Depending on the utilities given by the providers and the accounts made on the device, the master user has various and different options at his disposal.

For example, after creating accounts on Facebook, YouTube and Skype, the applications that help sharing information – news, photos, videos – give the possibility of uploading them directly on Facebook or YouTube, the messaging option works selectively with SMS, MMS, Skype and Facebook, and the phone provides GSM and Skype Calls services.

But the above details don’t matter so much. Overall, “communication” becomes easier; everything happens more rapidly. We’ve made one more step towards “better”; the concept of “shoot it, kill it, eat it” continues to function at improved parameters. The Show Must Go On! Deep down I’m not such a technical person, so I’ll abruptly turn towards the Bohemian side of the matter. I was at a cabin, partially due to New Year’s Eve Party, and I was told in a plain and civil way that I don’t belong to the “Smart” generation.

I don’t belong to it because I don’t use a smartphone which allows me to follow the informational trend.

On one hand, the convenient gathering of “friends” nose stuck in the colorful web. On the other, elaborating the detailed data sheet of own personal existence, using of course various online registry books, carefully put at the citizen’s disposal by the Big Brother.

TODAY SOFTWARE MAGAZINE

I didn’t get too angry, although I was considered backward and not so handy in terms of “Internet and stuff ”. I’ve easily got out of trouble just to step into a new one during my weekly portion of poison in the city’s pubs. This time I was scolded by the friend next to me and his lover for not attending a party.

To be all clear, the guilt was entirely mine – I don’t belong to the group to which the invitation was sent, and even worse, I don’t have an account. Although solid, the tone of the argumentation – “you find gals on Facebook and you can find out everything that happens in your city, about public/private parties. And for your information, the girls that were present, they had made an opinion about every boy at the party before…And when they arrived, they knew exactly who they wanted to be with!” and so on. - made me feel completely lost.

I started to mentally realize why I don’t like these means of interacting with reality.

So, I’ve continued my meditation. As a child, I was enjoying a lot the small stream that flowed across the alley in the countryside, the extreme part of the garden next to the hill and the lack of the real things that were happening over the mountains, which were impossible for me to reach. My feeling was also shared by a small group of lads and gals, whom I proudly called friends; they

were about 10.

Contrasting with the picture above, last autumn, after a private and pompous celebration of an actual friend’s birthday, I get another piece of information. This friend was telling me about his 1,700 online “friends”. The look on his face made me react, and, like the son of an accountant, I replied: “Man, you have as many friends as they were at your party yesterday and as many as they’d wish you Happy Birthday after deleting your birthday date from your profile”.

Well, greed is part of the human nature, and the bone does not necessarily come from a pig. I don’t have an authorization for generalization and I don’t know where I could get one, but I take the permission to make some small remarks. It’s my friends that I consider real, the friends I can count on the fingers of my hands, like a small friendly Spartan guerilla. Actually, these few people help me get through the lethargic days and the urban trances to which, I must confess, I conform myself.

Yet, even under these conditions, I hardly get the chance to spend quality time with every each of them, to say nothing of boasting about one or two thousands of them…

We all seem to be in a hurry to somewhere, but we don’t know where. We want something, but we don’t know what. We read a lot

but we remember nothing. The same nothing labels our walk from one institution to the other. The experiences lack the sacred, and even the cold and the heat have stopped creating a condition. They merely create a passing discomfort. We are tired of the artificial and this makes many of us feel wrong.

I don’t think it’s the end of the world – or who knows?! Therefore, it’s not such a big drama after all. I’m not going to keep talking about the apologetics of communication as human necessity versus the reverse of the word group, but as far as I know, it’s difficult to live a hermit’s life.

With or without computers and a nebula of services for not staying alone, one way or another, I think we’ll get through in the end. However, in what concerns the interhuman contact, the spontaneity, the verbality in most of the situations and of course the body language are the salt and pepper. Most of the times, the keyboard seems to become a wheelchair for a society of emotional paralized individuals, and smarphones help us carry the perfusion along.

It’s a sort of a madhouse and I feel the need to air my brains. Instead of working faster so I could have fun and relax faster, and cross the water one day in the same manner, I’d rather have grass and flowers and trees and superfluous stories about a pleasant nothing. Hey, I’m going for a walk!

www.todaysoftmag.com | no. 1/2012

39

powered by