Today Software Magazine

TSM

The problem of side effects

From an ideato a product

Creative compensation

Startups - Mintaka Research

No. 1 / 2012 • www.todaysoftmag.com

T O D A YS O F T WA R EM AG A Z I N E

6The problem

of side effectsOvidiu Deac

8Performance of

.NET applicationsFlaviu Măţan

16The Good, the Bad

and teh Ugly Ovidiu Deac

22Interview with the

Finalist Team at Microsoft Imagine Cup

Marius Mornea

26StartUpMintaka ResearchMarius Mornea

30From an ideea to a productOvidiu Măţan

33Creative compensation Ioana Fane

365 differences betweena lider and a bossAristotel Dascăl

3810 vs. 1700Presto - Allegro manon troppoAurel Popârţac

4 no. 1/2012 | www.todaysoftmag.com

Connecting the dots

Hello,

Welcome to our first issue of Today Software Magazine. The initial idea of hav-ing 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.

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 soft-ware 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 manage-ment. 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

editorial

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.

5www.todaysoftmag.com | no. 1/2012

TODAY SOFTWARE MAGAZINE

Editorial staff

Founder / Editor in chief: Ovidiu Mățan / [email protected] designer: Dan Hădărău / [email protected]

Translator: Nora Mihalca / [email protected] (Startups / Interviews): Marius Mornea / [email protected]

Editor (Programming languages): Ovidiu Deac / [email protected]: Ioana Fane / [email protected]

Collaborator: Flaviu Mățan / [email protected]: Aurel Popârţac / [email protected]

Collaborator: Aristotel Dascal / [email protected]: Romulus Pașca / [email protected]

Contact addressstr. Plopilor, nr. 75/77

Cluj-Napoca, Cluj, [email protected]

www.todaysoftmag.comwww.facebook.com/todaysoftmag

twitter.com/todaysoftmag

ISSN 2284-6360


The Problem of Side Effects

Ovidiu Deac

Independent software consul-tant specialized in agile deve-lopment methods and functio-nal languages.In his free time, he likes swim-ming, mountain climbing and motocross racing.

Known under the acronym OOP, the Object Oriented Programming was intro-duced 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 de-allocating 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.

TestingThe 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 under-stand 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 be-cause 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 func-tions. In many cases they are trivial to test because they don’t need setup/teardown

Programming



as they don’t depend on external compo-nents. Their result only depends on the in-put parameters.

ParallelismWhen an object is used from several

execution threads we need a synchroniza-tion 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 prob-lem is the cache coherence when several processors share mutable data. Even more, if the system is a distributed one, the prob-lem is increasingly difficult because syn-chronization 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 sur-prising 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 pro-duces a result based on the job description message.

Using some standard queuing mecha-nism 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 im-mutable 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 syn-chronization is a major advantage.

Asynchronous ExecutionThere are many situations when we

need to execute a certain sequence in an asynchronous manner. Next to the nor-mal 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 im-perative 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 calcu-lations 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 an-other “future” etc.

OptimizationsThe theory says that we should opti-

mize 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 sequen-tial 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 asynchro-nous late in the development.

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

LazinessIn some situations we want some cal-

culus 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 diffi-cult or even impossible.

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

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

MemoizationAnother 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 pa-rameters. It is done by storing the result of the calculus. When the next call is done we look up the results in the already-calculat-ed-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 calcula-tion itself.

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

ConclusionThe problem of object oriented pro-

gramming 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 re-sulted code would be simpler, more robust, easier to parallelize and optimize.

In the following articles from this se-ries we will discuss about functional pro-gramming which is different from impera-tive programming mostly in how it handles the problem of side effects.


Performance of.NET Applications

Flaviu Măţan

Principal Software Engineer at Ixia

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 perfor-mance 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 profilerDetecting 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 prob-lems and logging the measurements and ending by using dedicated performance profiling applications that provide complex measurement data collected at applica-tion runtime.

The first option is successfully used by top management to evaluate an applica-tion’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.

Programming



1. Ease of useBoth applications are very similar in

terms of starting and configuring the profil-ing session.

Each allows the user to choose the type of the application to be analyzed (stan-dalone app, Silverlight, web etc.) as well as the options related to the accuracy or detail level for the collected data (line level, meth-od 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 profil-

ing mode in which all threads are periodi-cally 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 applica-tion under test in terms of duration of ex-ecution. 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 enter-ing 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 appli-cation 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 leav-ing 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


included in this measurement typeCPU 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 measure-ment type.

3. Other optionsMethods 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 execu-tion (without a profiler attached).

Note on the table notation: Yes* repre-sents 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 8dotTrace Performance 4.5 6

Obtaining the profiling resultsThe two profilers have different mech-

anisms to collect profiling data between two points in time:

ANTS Performance Profiler 6.3 has the notion of timeline and dotTrace Perfor-mance uses the notion of snapshot.

ANTS Profiler timeline I must admit that the timeline is a so-

phisticated and spectacular control.

It is updated in real time as the profiled application is running and displays infor-mation 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.

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 par-ticular operation (e.g. opening a document) can be a tricky thing because it requires storing / identifying the starting and end-ing point of the operation. The sequence of actions for selecting a particular opera-tion would be as follows: we are just about to perform the operation we’re interested in optimizing or finding the performance is-sues; right before performing it we want to make sure we’ll be able to identify the start-ing 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 usu-ally 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-

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 ana-lyze. Or if the operation subject to profile involves a sequence of methods. A single window can be selected at a time. Its dimen-sions can include any subset of the timeline.

BookmarksBookmarks are saved along with sav-

ing 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 book-marks 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 inter-vals defined by the user.

Pros and ConsTimeline’s advantages include maxi-

Performance of .NET Applications

ANTS Performance Profiler 6.3

dotTrace Perfor-mance 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

Table 1 - Profiling options

Programming



mum flexibility in selecting time windows of any size, additional information such ex-ceptions 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.

dotTrace snapshot dotTrace Performance has a simple

data collection mechanism to collect pro-filing 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 snap-shot cannot be combined with other snap-shots.

Pros and ConsAdvantages: - Data collection is active only during

the snapshot capturing reducing the impact on profiled application performance (The performance impact of the profiled applica-tion 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 opera-tion is easy (start / stop snapshot)

Disadvantages: - Snapshots cannot be expanded

or shrunk (as with the timeline)

2. Analyzing the resultsBoth applications offer users an ar-

senal of features that facilitate finding the performance problems in the applications under test.

There are basic elements common to

both profilers such as using the same set of metrics (functions hit count, duration of methods etc.), outlining the most expen-sive 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 anno-tation capabilities, etc.

2.1 Viewing the results

Grouped by threadBoth profilers have a thread based,

tree-like, sorted (descending) by duration, method calls visualization mode. It can

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

Definitions: Call stacks - all the function call stacks

are recorded for each thread along the en-tire profiling data collection

Note: Both profilers have an op-tion 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 func-tion).

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 descrip-tion above at Percentage

Hitcount - represents how many times a method was called within a particular call stack.

Picture 3 - Selected timeline section to get the data for that time interval

Picture 4 - start data collecting

Picture 5 - stop data collection


Other presentation and grouping modes:

Flat List Both profilers have the flat list visu-

alization 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 dura-tion, hit count, name etc.).

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

2.2 Drill down Once we identified a suspicious func-

tion 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

can become frustrating if one needs to make the drill click by click especially in situa-tions 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 Perfor-mance 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 au-tomatically 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 provid-ing a very easy way to share the results with other people.

The equivalent drill down method of-fered 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 Jet-Brains) 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 analy-sis, especially when we know exactly which


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

Programming



Picture 9 - Flat mode profiling results, dotTracePerformance 4.5.1

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

Picture 10 - The Graphical Mode (only ANTS)


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 Perfor-mance 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 snap-shots 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 / markupAnother feature offered only by dotTrace Performance is the annotation / tagging of methods in the profiling results.Users can add comments for specific meth-ods and can highlight outstanding functions by changing the formatting and colors.

Simulate optimizations

Only the profiler from JetBrains provides such functionality via the Adjust Time fea-ture selectable from the context menu for a method. The adjustment can be made by sliding down from 100% to a percent repre-senting the estimated gain after a potential optimization. The adjustment can be ap-plied 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 perfor-mance measurements for both profilers made on a test application (the demo ap-plication that comes with dotTrace Perfor-mance 4.5.1):

From the measurements in the table we can draw some obvious conclusions:

- sampling mode has insignificant in-fluence upon the profiled application for both profilers

- tracing mode (or method level)

takes a little longer with dotTrace than with ANTS attached

- at line level things are very different as with dotTrace profiler attached the appli-cation 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 impor-tant when analyzing specific operations. In this scenario one can choose to run with the profiler attached but not to start collect-ing 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 excep-tion. Both profilers have similar influence on the memory.

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

4. Complexity of profiled applicationsFrom 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 (memo-ry 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




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

Programming



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, remain-ing as usable as with any other profiled ap-plication.

5. Other CriteriaProfiling I / O and SQL

- ANTS Performance Profiler 6.3 only. The functionality is provided only for op-erating 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 pro-filing 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 re-sults (in their binary format) is easier for the results obtained with dotTrace Perfor-mance 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 func-tionality.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 Profes-

sional 6.3 costs 595 Euros

6. Conclusion

ANTS Performance Profiler 6.3 25dotTrace Performance 4.5 21

Both profilers will help you success-fully 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 ap-plication 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.

Trial versions for the two profilers can be downloaded from the following loca-tions:

dotTrace Performance Profiler 4.5: http://www.jetbrains.com/profiler/download/in-dex.html ANTS Performance Profiler 6.3: http://www.red-gate.com/products/dotnet-devel-opment/ants-performance-profiler/

Operation duration without profiler attached: 10s



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



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


The Good, the Bad and the Ugly

Ovidiu Deac

Independent software consul-tant specialized in agile deve-lopment methods and functio-nal languages.In his free time, he likes swim-ming, mountain climbing and motocross racing.

In this series of articles I would like to compare various programming languag-es. 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 lan-guage, 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 dy-namic typing and its functional programming features, combined with the object-oriented 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 infer-ence. This means that, most of the time, the type signatures are not needed.

The ProblemLet’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• 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

cat • 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:...

Programming



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)

JavaThe 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.


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)); }

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 + “’”; } }}

The Good, the Bad and the UglyProgramming



Python 3Python 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 lan-guage 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 python3PROMPT = “>”

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()

print(“Ctrl+C to exit”) prompt() for cmd in stdin: try: print(execute(cmd)) except Exception as ex: print(ex) prompt() print()

Below is the function split_cmd which returns a tuple con-taining 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.

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 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)

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

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, par-am3).

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

The code above makes the call to the main function and han-dles 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.


HaskellThe 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...and the editor I used was geany. $sudo apt-get install geany

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

To generate an executable the compiler needs the Main mod-ule containing a main function:

module Main where

import System.IOimport Data.Listimport Data.String.Utilsimport System.Directory

Next is function main which has the default type “IO()”. This means that main doesn’t return anything but it produces side ef-fects 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 param-eter 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-

The Good, the Bad and the UglyProgramming

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 pa-rameters 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 signa-ture 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 separa-tor 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 ac-tually make the call to join. This is called currying. The code below reads as English: joinLines is joining strings by “\n”

joinLines :: [String] -> StringjoinLines = join “\n”

Below is the function execute which takes a series of equa-tions 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



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

execute :: [String] -> IO Stringexecute (“ls”:params) = ls paramsexecute (“cat”:params) = cat paramsexecute _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 Stringls [] = 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 Stringcat [] = 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

ClosingI expect the readers to send their opinions by email to [email protected], 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 lan-guages or alternative solutions are also welcomed.


Interview with the Finalist Team at Microsoft Imagine Cup

The “Interview” section of the first issue of our magazine has given us the op-portunity of meeting and knowing better a team of young students from Cluj, na-tional 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 person-ally and professionally, all these things summing up in a wonderful experience. Fur-thermore, 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/re-gions, 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’ per-formances 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 Develop-ment - Aether team – Silver in 2007. And the teams confirmed with Bronze – En-deavour 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-

Interview

Marius Mornea

Fost senior software develo-per in cadrul Nokia, în prezent fondatorul platformei Mintaka Research



tion had been well organized […] and many teams were encouraged to participate” (An-drei 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 men-tor’s help, who helped them “not to take all the wrong decisions”(Cosmin Mihaiu), they build an atmosphere which stimulates per-formance and quality, ingredients for cer-tain 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 expe-rience. 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 BizS-park 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 experi-ence 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:

What is MIRA?With „Medical Interactive Recovery

Assistant” we want to help any person suf-fering from a temporary locomotory handi-cap, persons who, for example, have suf-fered 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 used Kinect, a device from Microsoft, which was new at that time, to involve the user, actually the patient, in easy but recov-ery-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

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 com-pany), 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 world-wide final, […] what to do next? We were accompanied by Mr. Dan Suciu, our men-tor, 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 mar-ket, 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 Mi-haiu

„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

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 forgot-ten 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 success-ful, that’s why we are discussing and work-ing 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 Ro-manian press. We had TV appearances at ProTV and TVR. At the beginning of De-cember, 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 practi-cal application, a proof of the fact that there are software ideas from Romania, not com-ing from abroad. ” Cosmin Mihaiu.


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 par-ticipate, 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 Car-egamer, 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 mo-tivates you to put them to practice.” Andrei Dascălu

„By definition, Imagine Cup is a con-test which develops all your abilities: team-work, presentation skills, time manage-ment. 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

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.” Cos-min 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 four-wheel car, if one wheel is missing…it’s in vain.” Cosmin Mihaiu

„The presentation has the biggest in-fluence on the jury, 80% of the score.” An-drei 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. Eve-

ry one of us is good in his domain and I think…as a matter of fact I know not a sin-gle major decision was made without con-sulting 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 suc-cessful applications in the future. Let’s hope so!” Andrei Dascălu

Finally, Imagine Cup is the perfect op-portunity 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 competi-tion blog that Microsoft launches Imagine Cup Grants. With a budget of 3 million dol-lars 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. Imag-ine Cup has proved to be a wonderful expe-rience, as well as an IT career and business environment launching platform.

Interview with the Finalist Team at Microsoft Imagine Cup

Interview


StartUpMintaka Research

Researchers are often perceived as lonely individuals spending their whole lives closed in laboratories and working with complicated instruments or formulas. How-ever a little research will prove that most famous researchers collaborated, inter-acted 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 Con-rad 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 “miracle year”. Innovation and discoveries come as much from dedicated solitary work, as from collaborative re-search 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 Edu-cation 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 knowl-edge with both education and business, thus ensuring both continuity and new op-portunities to bring the latest innovations closer into our daily lives. The core phi-losophy 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 envi-ronment: 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 pur-poses), 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 del-egating 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 em-ployee 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-

Marius Mornea

Fost senior software develo-per in cadrul Nokia, în prezent fondatorul platformei Mintaka Research

Startups



portantly the predominant outsourcing na-ture 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 Technolo-gies User Group), RTC (Romanian Testing Community), AgileWorks Romania, Se-mantic 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 communi-ties promoting collaboration and specialist level knowledge sharing, in order to grow the innovation and quality on the local mar-ket.

The second solution proves to be more challenging due to a lack of constant de-mand for high level competences. The fluc-tuating 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 ex-traordinary developments in Romania’s re-search 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 Eu-ropean alignment efforts gave birth to an entire generation of Romanian researchers with real results, high levels of specializa-tion and international contracts. However, most of them were concentrated in the gov-ernment funded public education system, with a high degree of dependency between research, education and the political envi-ronment. Private research initiatives hold a very low percentage, European statis-tics showing the following research fund-ing evolution in 2008, by source: business 45.4%→23.3%, government 47.6%→70.1%, foreign 5.5%→4.0%. This means that the re-maining 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 bu-reaucracy decreases mobility, tying research specialists to the education and government system. Even so, a few local private initia-tives like Coneural, RIST (Romanian Insti-tute 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 fo-cus on research and achievement of maxi-mum 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 academ-ic 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 com-munity 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 spe-cialists, 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 ac-tive involvement in the educational pro-cess through knowledge sharing between market specialists, academic researchers, and educators in an effort to enrich the academic environment with extracurricu-lar activities, or even ways to align the cur-rent teaching curricula to the needs of the business environment. Thus we will support business experts collaboration with aca-demia, aiming to increase the quality of the didactic material, but also to raise the inter-est and motivation of the younger genera-tion, 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 refine-ment iterations, evolved into the collabora-tive, cross-domain research platform.

Now let’s take a closer look at the cus-tomer 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 to-gether for collaboration.

The PlatformIn practice, in order to support the

community and cater to the needs of such a heterogeneous target, we will offer an on-line platform that holds together a set of tools and services divided mainly in four categories: community, communication channels, knowledge repository and scien-tometrics. Content will be split in: general and user based authentication accessible content. Each category will be detailed in


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

The CommunityThis business component will handle

all community related services and interac-tions. The main building block of the com-munity section will be the competences pool: a centralized database of all com-petences accessible through the platform. The database will be built by aggregating information from all registered collabora-tors profiles, ranging from individual re-searchers to teams and organizations. Com-petences will be grouped based on several criteria: research (domain, technology, fun-damental, applied), development (domain, technologies, workload capacity), commu-nications (channels, audience), business (fi-nancing, HR), etc.

The Usage Model: each user can browse the competences pool. Helped by a tool, he will be able to build a generic com-petences team which will collaborate to achieve a goal. If the community offers all needed competences and the goal is reach-able, the user can finalize the team by pro-viding a clear specification of the goal and submitting it to the community. All avail-able users with competences that map to the newly created team will be notified by the system and can respond if they are will-ing to collaborate or not. When all needed positions are filled, the initiator of the pro-ject 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 al-lows a very wide range of interactions and maximizing the involvement of all resourc-es in order to reach all the paths described in the CVP Venn diagram.

The Knowledge RepositoryThis 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

organized in different categories as: papers, prototypes, processes, methodologies, pat-ents, 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 com-plete glossary of research methodologies and a collection of technology management techniques and processes. These are one of the core strategic strengths our organiza-tion intends to invest in.

The knowledge repository is not a pur-pose 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 pro-viding trainings and knowledge transfer consulting and secondly by searching for applications in the industry that could give birth to new ventures or partnerships. To-gether the two processes will join efforts to apply the knowledge in the repository back in the business environment.

ScientometricsAs the name implies, this component

will be responsible for measuring and ana-lyzing all scientific endeavors. From sim-ple free peer reviews, to industry wide re-sults 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 con-stantly 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 intend-ed to capitalize on large and high profile requests.

Two important partners in the sciento-

metrics effort will be the CENAPOSS gov-ernmental center and Ad Astra non-profit association, which already have national ef-forts in this direction.

The Research TeamBesides the community building ef-

forts and the platform and services offer-ing, we intend to create a research team with main interest in Autonomic Comput-ing. 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 build-ing 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 insti-tutions, gaining focus and freedom from the overly bureaucratic ways of the state system. It also creates a competitive ecosys-tem 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 se-lection 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, Re-search Methodologies, IP Management

- get practical help such as: peers re-views, benchmark of results, emergency staffing from the community etc

- contact the international associa-tions like IEEE , ACM, RSA to make their research visible and share it with other peo-ple.

StartUp Mintaka ResearchStartups



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 sys-tem to improve the quality of the teaching process, enrich curricula and motivate stu-dents, thus insuring continuity

- Partnerships with cross-domain re-searchers to bridge the existing commu-nication gaps and create value and new opportunities by combining and comple-menting our competences

The current political and economical context, both national and international, recognizes the need for quality research and supports initiatives that promote collabora-tive efforts to innovate and create new jobs

in the business environment. However, on a local level, there is currently a communi-cation 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 nov-el 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.


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 IdeaCreating 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.

SummaryHere 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 prod-uct: advertising plan, promotionals and product distribution strategy on various chan-nels.Use cases – Defining the way the product interacts with the users and the operating stepsFeatures 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 consider-ing the defined use-cases, it sets the product’s requirements, establishes the framework the product will function in, the expectations regarding its performance, scalability

Management

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.



and security. It represents the basic speci-fications the development team will build upon during product implementation.Product Positioning - Positioning the prod-uct on a market considering the existing of-fer and features matrix.Pricing model - Defining the product’s price according to its positioningLaunch plan - The plan of the product’s re-lease on the marketDevelopment of new products - The way we plan the next products’ release, taking ad-vantage of the previous product market, the existing skills and competences.

The VisionCreating new products and services

makes sense as long as one knows where he wants to get to. A product development strat-egy makes sense if it follows the company’s vision. This vision must consider the tech-nology and market evolution. For example, until iPhone’s launch, Nokia was the leader in mobile phones and smartphones. Their vi-sion 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 abandon-ing the development of Symbian Operating System and the transition to Windows Mo-bile.

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 evolu-tion 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 Labo-ratories were making desktop computers for test processing. Their lack of peripheral vi-sion made them go bankrupt in the 90’s be-cause 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 creat-ing 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 ecosys-tem designed for local communities. We’ll use our present knowledge to create products ac-cessible to anyone. The social networks will get a new meaning, integrating the real life into the virtual one.

Business CaseThis document is the background of

our project, it defines the new product and it will be used as reference for future docu-ments. 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 in-formation 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 fol-lowing 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 cre-ated before starting the project is the State-ment of Work (SOW). It describes the prod-ucts and services to be delivered. In case the implementation is done by another compa-ny, the document can be used as legal back-ground for all the services to be delivered. In practice, the contract and SOW are the main documents, according to which start-ing 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 com-pany. 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 rec-ommended to accept the following aspects:• Executive summary – it contains the

starting date of the project, the main stakeholders to benefit from the pro-ject, 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 im-portant aspects

• Short and long-term objectives • Return of Investment (ROI) – internal/

external benefits of project implementa-tion

• Project implementation including the resources to be used

• Implementation cost (see example) • Implementation cost (see example)


• 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 infor-mation about project costs in order to dem-onstrate the choice of a particular service provider, working method, details about project’s milestones, means of communica-tion during the project, project status pub-lishing etc.

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

project and Short and long term goal assig-nation.

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 [email protected]

From one idea to a productManagement



Creative compensation

Ioana Fane

HR Specialist UllinkCluj Napoca

The basic concept of the compensation management is quite simple: employ-ees 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 some-thing 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 tran-sition 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 special-ist, should tailor the employee’s personal needs and then they should be implement-ed 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 - finan-cial benefit, but also because of the economic stagnation forecast and thus wages.

From the companies perspective it is more convenient and cheaper to try re-taining the employees within the company and to try adapting the motivation poli-cies 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 re-wards 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

HR


to provide generous benefits, a rigorous fi-nancial planning should be put in practice. Most compensation and benefits packages are not cheap and costs can increase ex-ponentially 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 be-comes 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 compensa-tion package?

All aspects of each job offer are nego-tiable. Negotiating salary and other benefits is a vital skill that all successful IT profes-sionals 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 re-sources and the quality & quantity of spe-cialized 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 re-laxing way of living.

Small companies offer more generous compensation packages than large compa-nies or multinationals. Lack of brand noto-riety on the market and of a rigorous system in developing salary and benefits packages enables them to be more flexible and at-tractive for the recruitment market. On the other hand, the benefits package in IT com-panies are the most creative and generous.

While salary and benefits packages are becoming more complex, employee perfor-mance and potential candidates work re-sults are decreasing. This happens because of high staff turnover, which lowers indi-vidual and organizational performance but also the employees opportunity to special-ize.

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

ing attention to new offers and jobs imme-diately after this period.

Some companies decide to keep the re-muneration below market average wage lev-el and decide to hire young people, who ac-cept 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. Posi-tioning the wage above the average market will determine the HR department to focus on experienced candidates who have prom-ising results early in employment.

The question remains how compensa-tion would minimize the disproportion be-tween 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 mar-ket, but wage levels within the company. A brief analysis of costs shows that the turno-ver 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 pro-vided by companies to motivate their em-ployees are on the other hand, personnel management tools of interest to the em-ployer.

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 Christ-mas 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 depend-ing 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 con-

sidered benefits to the extent that exceeds the amount necessary to achieve limit as-signed duties - otherwise it is only a tool

• flexible work schedule - usually of-fered to those employees occupying mana-gerial positions rather evaluated according to results, not according to time actually spent in the office;

Compensation and benefits pack-ages are depending on business structure, recruiting, retention, motivation, perfor-mance 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.

Creative compensationHR


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 organiza-tions. But only some of them spread around them a special relational flavor, an at-tractive 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 teamThere 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 in-stead 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 profession-

al 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

Aristotel Dascăl, PMP

Motivational speaker. Spiritual explorer.

Management



says “Give me some examples so I can un-derstand 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 empath-ic, coming next to you at your own custom level. The boss loves to hear him giving so-lutions like pills.

3. The leader gives before he requestsA boss can request officially for some

activities to be completed, with no relation-ship 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 under-standing and satisfying the individual per-sonal 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 effective-ness. That’s why he doesn’t hesitate to do the “low” activities that usually the team mem-bers 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 be-cause the followers choose to follow him

The most obvious way to recognize a leader is his team following him by in-stinct. 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)


10 vs. 1700Presto - Allegroma non troppo

As I was working in a far away land, over a sea and 5 countries, I started medi-tating 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 perti-nent, 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 ser-vice providers, we integrated the simple line particular to such a system – Phone, Messaging, Photo/Video Gallery – with the services offered by the providers. De-pending 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 ap-plications 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 “bet-ter”; the concept of “shoot it, kill it, eat it” continues to function at improved param-eters. 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, us-ing of course various online registry books, carefully put at the citizen’s disposal by the Big Brother.

Aurel Popârţac

Software engineer, owner of an IT business

Philosophy



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 at-tending 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 every-thing that happens in your city, about pub-lic/private parties. And for your informa-tion, 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 country-side, 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 on-line “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 na-ture, and the bone does not necessarily come from a pig. I don’t have an authori-zation for generalization and I don’t know where I could get one, but I take the per-mission 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. Actu-ally, 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 boast-ing 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 some-thing, but we don’t know what. We read a lot

but we remember nothing. The same noth-ing 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 arti-ficial 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 talk-ing 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 neb-ula of services for not staying alone, one way or another, I think we’ll get through in the end. However, in what concerns the inter-human contact, the spontaneity, the verbali-ty 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 par-alized 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!

powered by

Today Software Magazine

Documents

Transcript of Today Software Magazine