Posts tagged C#
Master thesis – Typical use case
2Because of the specifics of the brainstorming activities, there are two sets of features that must or can be implemented: the first ones which regulate the brainstorming activity as a set of rules; the second ones add productivity to the process, enabling additional scenarios that improve the user experience. In the first phase of requirements elicitation for such a system, the Microsoft Surface was chosen as a direct, face to face collaboration. For enabling the sharing of Brainstorming session, BSCW system was chosen as it enables shared workspace paradigm, allowing easier collaboration and cooperation among users with common interests.
Detailed usages of typical brainstorming and idea generation tools were presented in Related work. What all this papers have in common are few scenarios which are very important for the idea generation process:
- Creation of ideas and inserting them into the system (e.g. Creating text items with brainstormed ideas)
- Editing (e.g. Correcting, improving and augment with graphical elements the already existing items)
- Grouping through visual clues (e.g. creating logically grouping structures with the aid of visual elements)
- Relating (e.g. creating a tree-like relation that gives a structured form to the ideas generated through the process towards a specific goal)
A typical user scenario is presented to clarify the use and features provided by the system.
Anton, Kai and Vladimir are three students developing applications in Fraunhofer FIT under the supervision of a research assistant, Greg. They set up a meeting in the User Experience lab, where the Microsoft Surface is, and set as their goal to create a new system for helping people with Alzheimer.
Because Greg is the coordinator of the brainstorming session, he uses its card to login into his BSCW system which will be later used as a repository and central sharing hub for the outcome of this session. Then he inputs the text “Alzheimer project” into the central control on the application, allowing all of them to keep focus on their goal. They start adding to the Surface the ideas that they have, as the brainstorming process is about quantity. When they feel that a small dose of inspiration is required, they use the application’s feature of searching in Twitter or Flickr for fresh ideas or hints. Since they work on the same device, the awareness of each one presence is complete, conversations start over some interesting features, raising more and more ideas for their project.
After the main part of the brainstorming is finished and all ideas are inputed on Microsoft Surface application, the next phase starts – reviewing their ideas and correct the small mistakes that they made in typing. Anton also quickly adds some more visual hints to ideas, like arrows pointing to the text or underlines some important keywords. Kai enjoys the dictation feature of the application to quickly add some more information to some ideas that he feels that aren’t very well explained.
With all ideas correct and complete, they go into the next phase of requirements elicitation for their application start grouping them into functional and non-functional features for their system, using the background colors to create visual hints. This enables them to have a quick overview on the ideas they gathered and relate them to a specific part of their software planning.
The nest step in the process is to link the ideas into a tree like structure, as all good software developers do, identifying the dependencies between the ideas. This will prove useful later, when they will create the necessary UML diagrams for the software.
Since they will go afterwards to their own workstations and they need to review and create the appropriate documents for their project, Greg uses the saving feature of the application, which will create a folder in his Workspace on the BSCW system. In it he will later find a screenshot of the application’s screen to have a quick visual of the session, the entire session metadata saved as XML for later use in other applications and a collection of all ideas saved as HTML documents.
Because all work needs to be shared and the session repository is on the BSCW system, Greg can share his session with his colleagues by inviting them to the session directory. Thus, not only that all of them will have access to the session, but they can choose later to present the outcome of their work to their Professor, by using the Load session capability of the Microsoft Surface application.
An additional scenario can be used with this application, if there is time for Brainstorming session preparation:
If they have time to prepare for the meeting, some rough ideas may have been conceived before and they want to share with each other. Because using the Microsoft Surface is not possible with prior reservation, they may use the additional clients of the system to record their initial ideas: Adobe Air application (available for Windows, Linux and Apple) and an iPad and iPhone client for the mobile devices. Anton and Vladimir use the Adobe Air client to quickly create and send their ideas to the Surface default user, where the brainstorming items will be recorded and made available in the next Brainstorming session. Kai uses its iPhone to do the same, as he gets its best ideas while commuting.
Next let’s see how the requirements look like!
Master thesis – Concept
0The present article will present possible answers to the research questions presented in already existing work. The thesis must further investigate their correctness and evaluate the implementation of these solutions with the help of users.
A framework for analysis was used to search for the solutions proposed by other brainstorming applications and six direct categories aroused from the research questions:
- Additional features to improve the usability of a brainstorming supporting application;
- Input devices / mechanisms to register ideas into the system;
- Post brainstorming organization of ideas
- Mechanisms to support the brainstorming session;
- Solutions to address the physical limitation of the tabletop;
- Is the brainstorming session result used by other systems?
My thesis claims as a basic concept that an ideal tabletop application supporting the brainstorming process must have an implemented answer to the issues raised above.
Considering the first category of additional features which makes an application usable in the context of the brainstorming process, some properties were already mentioned and looked for in different applications: organization of ideas, relationships between ideas, sessions save and session restart for being continued. A new solution proposed by the thesis is the rating of ideas. Of course, the brainstorming session must not be influenced by categorizing the ideas in any way. However, there might be some ideas on which everyone to agree that they need to persist and need to be considered after the session end with high priority. In order to remember those very good ideas which meet the approval of everyone a rating mechanisms should be implemented.
The rating mechanism is intended to help the brainstorming session members to remember important ideas generated in the process. Nevertheless, if it is discovered that the rating of ideas is more an impediment to the creative process than a benefit, the rating mechanism can be enabled only in the evaluation phase of the brainstorming session.
The software touch keyboard is the usual mean of registering the ideas in an application running on the tabletop. This might be considered a difficult way to input the ideas by some participants. This is why the usability of a brainstorming supporting application would increase if more input means can be provided. Additional to typing on the keyboard on the table, a normal microphone could be used as an input device allowing the participants to give their ideas by normal speech. This method requires a speech recognition program in order to get the idea textually registered and consequently written on the table.
Moreover, the thesis claim is that graphical ideas can be important to the brainstorming process additional to the textual ones. Thus another way of registering a graphical idea into the application is to draw it with the finger on the table.
A brainstorming supporting application should address the scenario in which the participants get stuck and no new ideas are generated in a predefined time interval. As a mechanism to support the brainstorming session, the thesis proposes meshing with another system to bring up content related to the topic of the brainstorming session. For example bringing 5 – 10 tweets related to the topic could positively influence the creative process and get the session on track.
The system which supports the brainstorming process around a tabletop should address the scenario in which there are more participants than can physically fit around the table. This faucet of the brainstorming application can be the feature of adding other devices to the same idea generation process, as the tabletops have finite space that people can occupy in order to access it. A practical solution in this scenario is to allow people, using their own mobile phones, to interact with a mobile client of the application. They can use it to textually write their idea on the mobile device and sending it afterward on the table. In this way, they are not required to sit at the actual table to be able to participate with ideas.
Actually, in the scenario of having too many participants at the brainstorming session, it might be a good idea that everyone uses the mobile devices to input ideas and none of them to sit at the tabletop. This way no one has a preferential sitting place. The tabletop device can be used only to organize the ideas in a next phase when the direct manipulation is essential.
After the brainstorming session has ended and analyzed, the result should be persisted. It is possible and advised by the present thesis that the ideas resulted from the brainstorming session to become registered ideas in another system which can further make use of them. For example, the result might be saved as a list of Idea objects in a permanent repository system (like a CMS) in order to be used in a project or just to become available in a shared workspace.
Let’s see how the typical use case looks!
Master thesis – Related work
1As we read before in the Introduction, collaboration is a recursive and iterative process with the purpose of solving a problem or a situation in a systematic way (Dictionary 2007). It implies two or more individuals or organizations involvement in a mutually interested common goal. This process is creative in nature and its results are dependent on knowledge sharing, on learning from each team member and on building consensus towards a commonly recognized solution. Because humans are essentially different, the tendency is to form strong believes based not only on objective facts, but also subjective. Thus leadership is required, allowing all participants to express themselves and keep also the entire process focused on a specific path towards the goal. (Hilliges und al. 2007)
The collaboration process is also based on the fact that one people might not have the entire knowledge base required to solve a complex problem. Additionally, because each individual has a different understanding of the information, the knowledge might be distributed and sometimes controversial. There is a “Symmetry of Ignorance” (Fischer 2000) defined, in which different people are collaborating together, each one having different background and knowledge. They complete each other, learning and teaching, presenting the situation perceived through their different viewpoints, discovering alternatives or subtle problems of others’ proposed approach.
The basic requirement a system has to fulfill in order to be considered as supporting the brainstorming process is to allow the registration of ideas and their display in one place. This is a very basic purpose, as even a pen and pieces of papers can fulfill it. Yet without it we cannot conceive the support for a brainstorming session.
A second requirement to be fulfilled by a system in order to be considered is to use the Natural User Interface paradigm, as this is the subject of interest.
All other features which affect the level of system’s usability are considered additional.
Deriving from the research questions and from the interest of the thesis, a framework for analysis has been developed. The framework will be used to evaluate the brainstorming applications and to investigate their solution to the research problems. The properties of the framework can be divided into five categories.
- Additional features that the present thesis investigates are related to manipulation of ideas and brainstorming sessions, features which have an impact on the usability of any system supporting brainstorming:
- The ability to organize ideas into groups or categories;
- The possibility to create relationships between ideas, linking them into logical constructions;
- Saving the session is an important feature, as it allows the results to be persisted over the time;
- Resuming the session is also important, allowing other teams to further continue and improve the brainstorming session result.
- The interactivity would benefit from using natural gestures, allowing the participants to focus more on ideas and less on the tools to input them into the system (Billinghurst 2008). Additionally, it would be interesting to know what input devices / mechanisms are available and in what degree the users prefer to use each of them.
- To answer the research question regarding the way to support the brainstorming process the framework proposes to investigate the mechanisms used by the related systems to help the brainstorming session and the idea generation;
- It is interesting to study if the brainstorming session is used by other applications. Hence, the thesis will look for the integration of the related applications with other system as a baseline;
- One other research question the thesis must answer is about the mechanisms to address the physical limitation of the tabletop. Therefore, the framework will investigate how do other brainstorming applications address the scenario when too many people join the session to be able to position themselves around a physically limited tabletop.
The research on collaboration using tabletops is quite extensive for how few actual commercial devices exist, but nonetheless it shows the potential in this area. A matrix with the features provided by each system is presented below in Table 1 – Matrix of the features employed by the related systems.
|
|
Reviewed systems |
|||||
|
Questions |
Breyn |
Touch & Write / LeCoOnt |
Pond |
WeSearch |
Docubits and Containers |
APDT |
| Organization of ideas |
Yes |
Yes |
Yes |
Yes |
Yes |
Partially |
| Relating ideas |
Yes |
Yes |
Yes |
Yes |
Yes |
No |
| Saving session |
No |
Yes |
Yes |
Yes |
Yes |
Yes |
| Resuming session |
No |
Yes |
Yes |
No |
No |
N/A |
| Supports other input devices |
No |
Yes |
No |
No |
No |
Yes |
| Helpers for idea generation |
No |
No |
No |
No |
No |
No |
| Integration with other applications |
No |
No |
No |
No |
No |
Yes |
| Physical limitation addressed |
No |
No |
No |
No |
No |
No |
Table 1 – Matrix of the features employed by the related systems
Analyzing the above table, an interesting result arises. Almost all application have the basic properties of organizing and relating ideas. On the other hand almost none of them helps the brainstorming session and don’t address the physical limitations of the tabletop. Additionally, only one of them allows the result of the brainstorming session to be reused in another application.
As we can see, none of the already presented systems meet all requirements. Thus, I will introduce a concept for new application – Brainstorming activity support on multitouch and multiuser devices.
Master Thesis – Introduction
2
The advent of multitouch interfaces leads the interaction between people to new levels of complexity. In the same time it had an impact on the software development: instead of interpreting just a couple of input devices, the software must now interact with multiple fingertip contacts, tags and objects placed on the device. This is quite a big jump from the classical combination of the mouse and the keyboard. Because of the technical difficulties, the multitouch interfaces started to be present on small devices and just one user being capable of controlling the device. Later they evolved to being available also for large devices, usually horizontally oriented, that enable multiple user interactions on the same set of objects. Although some users had more devices, like a special mouse, tablet or joystick, the interaction was quite the same – one user, one computer, usually just one device used in one time.
Along with the increasing computer power the multitouch and (some of them) multiuser devices got more and more complex, not only in respect to the underlying hardware, but mostly regarding the software responsible for driving the experience. New software controls and frameworks were created to support multiple interactions, but this was not all – a new User Interface paradigm was needed.
The natural gesture of touching employed by the new devices’ interface led to it becoming ubiquitous. The interface dissolved itself in the device that we are using, creating a more natural interaction. And so the term Natural User Interface was born. This paradigm of interaction became supported by few different companies who understood that the customers using their devices appreciate their experience when it is simple and as natural as possible. People are not required to learn complex functions or sequence of key presses in order to get a simple result – a swipe of finger on the screen might be enough. Replacing the learning cognitive processes and choosing based on understanding and pointing allows users to concentrate on what they do, as opposed to how to do it. This allows them to easily express their imagination without interruptions due to remembering sequences of actions from the memory.
The questions that arise from this approach are many: regarding implementation due to system novelty and relative low number of resources for creating applications, and regarding social aspect addressing issues like how do the participants feel using the system, as opposed to the traditional approaches.
My thesis proposes itself to study:
- If the User Experience using brainstorming applications running on multiuser multitouch tabletops is engaging;
- If it is useful to have post-brainstorming ideas organization;
- If is the brainstorming process successfully supported by mashing with other systems (e.g. Twitter);
- If is integration with small mobile devices a good solution to address the physical limitation of the tabletop;
- Is it important to be able to persist the result of the brainstorming session?
Let’s see what other scientists did before!
Improving Coding4Fun’s AboutPrompt
1
While creating the Windows Phone7 version of my Master Thesis project, I needed to show some custom dialogs. Since Coding4Fun has some very nice dialogs, I explored the way that they might be customized to fit my needs. I needed a quick solution to a pressing problem.
I got in touch with this controls through WinPhoneGeek’s article Coding4Fun Toolkit for WP7 Overview and Getting Started, where he presented from the eagle’s eye the controls in the package. I was interested more in AboutPrompt control, but unfortunately he didn’t had it presented in the detail. (more…)
Windows Phone 7 Coding Camp
2
Just joined Microsoft Students Partners for few days, and me and my colleagues in Team West were invited to a Code Camp for learn developing for Windows 7 Phone with XNA. The camp was established in the castle, in Freusburg. We traveled from Köln after my RIA Business Applications presentation in the Springboard conference.
This special event joined together five very known and respected Microsoft Evangelists: Frank Fischer, Oliver Scheer, Frank Prengel, Tom Wendel and Jan Schenk. They are experts and known figures in programming world, with expertise in Windows Phone 7, Silverlight and XNA.
In the landscape of the castle, with Towers and defensive walls, we’ve been Knights .. of Code, of course (in German is Code Ritter). The organization was purely German: perfect! We had a lot of fun, lots of presentations and access to the knowledge gathered along the years of all five Evangelists.
In the first evening (who was right our Team West own event), we had the Microsoft Phone introduction by Frank Prengel (also known as Dr. Mobile) , XNA presentation by Tom Wendel (The Ant Man) and Silverlight presentation by Oliver Scheer, known as “Mr. deep zoom”. After all presentation, a collective brainstorming revealed around 30(!) ideas for implementing next day, who were judged from usability, possibility of creation and interesting points of view by our 5 Evangelists. Finally, we created teams based on the projects appealing to us. We followed our instincts and smell the code inside each application promise.
Alensa Online
0
Position: Team Leader and Lead Developer in Alensa Online – Software Development department
I was part of Alensa team between January 2007 and August 2008. Only the opportunity to study Media Informatics Master, held by RWTH Aachen University, could gave me enough reasons to leave Alensa Online that I enjoyed so much for almost two years.
I was in charge with our brand new solution for an online Healthcare project – Alensa Online. The Alensa Online Shopping site (www.alensa.ro) consists of an internet healthcare platform in Europe that would simplify research and self education related to health issues, and provides the customers with an interface allowing them to easily get their health questions answered by professionals. It was first developed by a third party company, then I took over the responsibility of developing and maintaining the solution.
My responsibilities were quite complex because I was the first hired person, very similar with Softwise company. This reminded me about the joy and responsibility that comes with this. Another nice surprise was to find in person of Mr. Alex Savic, the CEO of the company, a friend with whom I shared both technical discussions and personal development ones, he was one the most supportive about my decision to study in RWTH Aachen.
Shortly, at Alensa Online I were in charge with:
- Architecting and developing the web based solution using Microsoft ASP.NET / C# and SQL 2005 Server technologies;
- Performing server administration, configuration and maintenance for the Windows 2003 server, for IIS 6 and for SQL 2005 database server;
- Executing architectural modifications in order to make the website user friendly;
- Identifying, designing and developing solutions;
- Periodically testing the site functionalities and thus creating a real test environment, test cases and bug fixes;
- Performing code review, corrections and code optimization;
- Analyzing hardware/software requirements and proposing hardware/software improvements and suggestions (for example, choosing an appropriate hosting partner);
- Implementing real time traffic analysis tool to help the management department;
- Conducting internal training for his colleagues. (more…)
Adding events to LINQtoCSV library
0
The User Experience that a library provides must be at least equal with is quality and speed. And frankly, CSVtoLINQ rocks on latest two, as I presented in previous articles Import CSV file and query it with LINQ and continuing in LINQ wonder world, but lacks a little on the User Experience(in our case Developer Experience) by not having some events of starting, progress and ending of the parsing.
Especially important, while parsing huge files, is a confirmation for the user that something happens and (ideally) the point in which the processing is. That is why, thanks to Matt Perdeck for sharing the entire source of the library, I was able to improve it by adding events.
So, let’s see some code!
Modifications into LINQtoCSV library – CSVContext.cs
Important: All modifications will be made in the CsvContext class from LINQtoCSV namespace – the CSVContext.cs file.
First we’ll add the ReadStarted event to the library – it will fire when the reading of the CSV file has started.
// defining the delegate
public delegate void ReadStartedHandler(object sender, EventArgs e);
// here we define the event
public event ReadStartedHandler ReadStarted;
// the call of the event processing
protected virtual void OnReadStarted() {
if (ReadStarted != null) {
// we use empty eventargs because nothing is needed on readstarted event, just the confirmation of parsing started
ReadStarted(this, EventArgs.Empty);
}
}
LINQ wonder world
0I am sure that, if you are a developer, at some point in your career heard about and asked yourself: what is LINQ? If not, there’s no problem, you’ll find out now : LINQ comes from language-integrated query and it is a collection of extensions to the .NET Framework that encompass language-integrated query, set, and transform operations. It helps developers by extending both C# and Visual Basic, adding native querying capabilities to these languages. It also comes with class libraries to get the full advantage out of these capabilities.
As we discussed in my previous article, Import CSV file and query it with LINQ, we are able to load and parse the file into a IQuerable collection, thus giving us the oportunity to do more and more SQL- like operations on it.
The C# 3.0 specification defines a so-called Query Expression Pattern along with translation rules from a LINQ expression to an expression in a subset of C# 3.0 without LINQ expressions. The translation thus defined is actually un-typed, which, in addition to lambda expressions being interpretable as either delegates or expression trees, allows for a great degree of flexibility for libraries wishing to expose parts of their interface as LINQ expression clauses. For example, LINQ to objects works on IEnumerable<T>s and with delegates, whereas LINQ to SQL makes use of the expression trees.
Import CSV file and query it with LINQ
0 Assume that you have an plain text, old Comma Separated Values file filled with your precious export from a legacy system. How can you process it easily now? The first answer that comes to mind is to parse it and load it into a datatable and later process it by using DataTable.Select() method. But this approach has some limitations – like splitting data into several tables and then join them.
One would imagine that parsing CSV files is a straightforward and boring task, given that it is quite a while since CSV is around. Some of them are correct – in the sense that many implementations merely use some splitting method like String.Split(). Some don’t even offer the specification of the values splitting character – so your file wouldn’t be parsed correctly if instead of , you have ; as separator – yet another thing to modify if you’re lucky enough to have the sources. Others will not handle properly field values with commas because the simple split method of the String class. But there are better implementations that take care about escaped quotes, trimming spaces before and after fields and other small and useful details, but very few that I found did it all as I liked it – and at least as importantly, in a fast and efficient manner.
Radu Poenaru » Master thesis – Related work
[...] me on twitter « Master Thesis – Introduction Master thesis – Concept [...]
3 weeks ago