Kreidebrett™ is more than a simple web portal solution. It integrates social networking features, extensive voting capabilities, ePayment integration and community development controls. With community driven learning modules Kreidebrett is more than a simple eLearning solution. Service-oriented architecture enables seamless integration for mobile devices such as iPad, iPhone or Android systems. Learn wherever, whenever you like – with ultra fast responses to questions and requests.

Then trick behind the system is to motivate users by sophisticated gaming elements known from MMPORGs. Massively multiplayer online role-playing game (MMORPG) is a genre of computer role-playing games in which a very large number of players interact with one another within a virtual game world. As in all RPGs, players assume the role of a character (often in a fantasy world) and take control over many of that character’s actions. The majority of popular MMORPGs are based on traditional fantasy themes, often occurring in an in-game universe comparable to that of Dungeons & Dragons. Some employ hybrid themes that either merge or substitute fantasy elements with those of science fiction, sword and sorcery, or crime fiction. Still others draw thematic material from American comic books, the occult, and other genres. Often these elements are developed using similar tasks and scenarios involving quests, monsters, and loot. Another popular theme in MMORPGs is the past/future. Often times, in the past, you are a character who fights mythical monsters such as dragons, demons, and sorcerers. While in the future, you fight mechanical beasts such as robots or cyborgs.

MMORPGs almost always have tools to facilitate communication between players. Many MMORPGs offer support for in-game guilds or clans (though these will usually form whether the game supports them or not). In addition, most MMOs require some degree of teamwork for parts of the game. These tasks usually require players to take on roles in the group, such as those protecting other players from damage (called tanking), “healing” damage done to other players or damaging enemies.

The major finding of the study was that almost regardless of the experimental manipulation employed, the production of the workers seemed to improve. One reasonable conclusion is that the workers were pleased to receive attention from the researchers who expressed an interest in them. The study was only expected to last one year, but because the researchers were set back each time they tried to relate the manipulated physical conditions to the worker’s efficiency, the project extended out to five years.

Four general conclusions were drawn from the Hawthorne studies:

• The aptitudes of individuals are imperfect predictors of job performance. Although they give some indication of the physical and mental potential of the individual, the amount produced is strongly influenced by social factors.
• Informal organization affects productivity. The Hawthorne researchers discovered a group life among the workers. The studies also showed that the relations that supervisors develop with workers tend to influence the manner in which the workers carry out directives.
• Work-group norms affect productivity. The Hawthorne researchers were not the first to recognize that work groups tend to arrive at norms of what is “a fair day’s work,” however, they provided the best systematic description and interpretation of this phenomenon.
• The workplace is a social system. The Hawthorne researchers came to view the workplace as a social system made up of interdependent parts.

For decades, the Hawthorne studies provided the rationale for human relations within the organization. Then two researchers used a new procedure called “time-series analyses.” Using the original variables and including in the Great Depression and the instance of a managerial discipline in which two insubordinate and mediocre workers were replaced by two different productive workers. They discovered that production was most affected by the replacement of the two workers due to their greater productivity and the affect of the disciplinary action on the other workers. The occurrence of the Depression also encouraged job productivity, perhaps through the increased importance of jobs and the fear of losing them. Rest periods and a group incentive plan also had a somewhat positive smaller effect on productivity. These variables accounted for almost all the variation in productivity during the experimental period. Social science may have been to readily to embrace the original Hawthorne interpretations since it was looking for theories or work motivation that were more humane and democratic. – Franke, R.H. & Kaul, J.D. “The Hawthorne experiments: First statistical interpretation.” American Sociological Review, 1978, 43, 623-643.

Regression is going back and re-reading a section of code that you feel compelled to for whatever reason. In practice, avoiding regression is only advisable while you are doing exercises to develop your skills, not for actual material that you need to understand. Common sense tells you that if you are debugging to understand something and there is something that you didn’t understand, there is merit in going back and debugging something again.

The eye movement patterns of “natural” 10,000 WPM speed readers usually appear to be completely random as they look over a page. Their eyes move both forwards and backwards in order to “fill in the blanks” that they did not “capture” or “understand”. They can often be seen flipping pages backwards to look back at a previous page they already read. Developing a habit of becoming aware of something you did not completely understand and going back to read it with scrutiny is a critical habit to develop for comprehension rather than pushing ever forward in the pursuit of speed.

Cognitive Debugging™ and Speed Debugging™ in all forms is essentially incompatible with long term memory. You cannot speed debug your code and expect the information to stick no matter how well you understand the material in short term memory or how aggressive your comprehension techniques are. Cognitive Debugging™ and Speed Debugging™ can be used to go through reviews of past code and parts that do not require deep comprehension. Slower debugging skills are used on new material that requires thought and reflection.

The bottom line is that you have to repeatedly use information in short term memory within about 20 minutes of debugging code, or else it has no chance of making into long term memory. With the amount of information a Cognitive Debugging™ and Speed Debugging™ tries to tackle, finding uses for it all within 20 minutes is improbable. Cognitive Debugging™ and Speed Debugging™ is however a visual intake of information which can be, though loosely, compared to viewing a movie. After viewing a movie, you can remember individual scenes for years afterward even though you may have only seen them for a fraction of a second.

Nothing can substitute for sane, normal study skills taught at your local community college. Committing information to long term memory simply requires a very different approach. It simply takes time and effort to commit things to long term memory. Cognitive Debugging ™ and Speed Debugging™ is another tool in your study toolbox which you can pull out and use when the time is appropriate, like for quick reviews, to find information, for research and other appropriate times.

MORE ON THIS

Generally, high-level programming languages, such as Java, make debugging easier, because they have features such as exception handling that make real sources of erratic behaviour easier to spot. In lower-level programming languages such as C or assembly, bugs may cause silent problems such as memory corruption, and it is often difficult to see where the initial problem happened. In those cases, memory debugger tools may be needed.

In certain situations, general purpose software tools that are language specific in nature can be very useful. These take the form of static code analysis tools. These tools look for a very specific set of known problems, some common and some rare, within the source code. All such issues detected by these tools would rarely be picked up by a compiler or interpreter, thus they are not syntax checkers, but more semantic checkers. Some tools claim to be able to detect 300+ unique problems. Both commercial and free tools exist in various languages. These tools can be extremely useful when checking very large source trees, where it is impractical to do code walkthroughs. A typical example of a problem detected would be a variable dereference that occurs before the variable is assigned a value. Another example would be to perform strong type checking when the language does not require such. Thus, they are better at locating likely errors, versus actual errors. As a result, these tools have a reputation of false positives. The old Unix lint program is an early example.

For debugging electronic hardware (e.g., computer hardware) as well as low-level software (e.g., BIOSes, device drivers) and firmware, instruments such as oscilloscopes, logic analyzers or in-circuit emulators (ICEs) are often used, alone or in combination. An ICE may perform many of the typical software debugger’s tasks on low-level software and firmware.

Anti-debugging is “the implementation of one or more techniques within computer code that hinders attempts at reverse engineering or debugging a target process”. The types of technique are:

• API-based: check for the existence of a debugger using system information
• Exception-based: check to see if exceptions are interfered with
• Process and thread blocks: check whether process and thread blocks have been manipulated
• Modified code: check for code modifications made by a debugger handling software breakpoints
• Hardware- and register-based: check for hardware breakpoints and CPU registers
• Timing and latency: check the time taken for the execution of instructions

Debugging can be inhibited by using one or more of the above techniques. There are enough anti-debugging techniques available to sufficiently protect software against most threats.

In this modified version of debugging, rather than the incoming flow of information being the focus of attention, active cognitive processes that organize information dominate the forefront of the attention, with debugging “skills” serving only to provide information for the code preparation.

All speed increases or decreases, complete stops, or regressions are at the behest of the logical making part of the brain. When the developers mental prototype of the analysis he is preparing has “gaps” or stalls or “holes” in it because of a lack of understanding of the material, the mostly unconscious “data input” part of the debugging phase immediately begins rapidly searching both backwards and forwards through the code for information to fill in the holes.

Essentially, the conscious attention of the active debuggee is 100% oriented towards feedback on comprehension, because he is actively paraphrasing everything that is read and actively filtering out useless ideas he doesn’t want to include in his analysis. This is VERY VERY different than passive patterns of debugging the text in a high speed linear fashion, which is akin to trying to force the brain to make sense out of a thousand speeding bullets whizzing by. The brain is CONSTANTLY monitoring its own comprehension, and actively deciding which parts of information to ignore and which to utilize. Every word that is read is read at the behest of the mental processes that are attempting to do something with information. Not all reading material is organized in a fashion that allows this technique to be useful.

This technique, and others like it require the developer to be able to visualize information in their heads in the same manner as a whiteboard (or chalkboard), to think visually. Thinking visually is many many times faster than thinking in an audio fashion, trying to sound out words to oneself, or verbally ponder the meanings of what is being read. This class of technique calls for the debuggee to picture the information they are reading in a visual representation of the material being read mixed in with the information they already know about the subject. Not everyone can do this, but with practice between 10% and 30% of people can eventually pull this off with limited success. Some (such as this author) think so rapidly in an inherently visual manner that they can keep up the whiteboards in their heads at speeds over dozends lines of code per minute. It takes a lot of sleep, a lot of good food, a fair dose of caffeine, an inherent ability to think visually, and the willpower to master the technique. While it may sound like freak mental abilities are needed to do this, actually what happens is that freak mental abilities develop with practice. What is required is translating your thinking processes into visual representations. Huge portions of the human brain are dedicated to processing information visually, and as a result they are the fastest circuits in the brain for processing information. They simply need to be trained through practice.

By far the most effective visual thinking patterns for this purpose are modeling ones thinking after Mind Maps. Very quickly you will get used to the techniques of organizing information visually in your head.

Debugging is a methodical process of finding and reducing the number of bugs, or defects, in a computer program or a piece of electronic hardware thus making it behave as expected. Debugging tends to be harder when various subsystems are tightly coupled, as changes in one may cause bugs to emerge in another.

Debugging is, in general, a lengthy and tiresome task. The debugging skill of the programmer is probably the biggest factor in the ability to debug a problem, but the difficulty of software debugging varies greatly with the programming language used and the available tools, such as debuggers. Debuggers are software tools which enable the programmer to monitor the execution of a program, stop it, re-start it, set breakpoints, change values in memory and even, in some cases, go back in time. The term debugger can also refer to the person who is doing the debugging.

Cognitive Debugging™ (incl. Speed Debugging™) is a collection of debugging methods which attempt to increase rates of debugging without greatly reducing comprehension or retention. Methods include chunking and eliminating subvocalization. It is important to understand that no absolute distinct “normal” and “Cognitive Debugging™” types of reading exist in practice, since all developers use some of the techniques used in Cognitive Debugging™ and Speed Debugging™ (such as identifying operators and operands without focusing on each letter, not sounding out all words, not sub-vocalizing some phrases, or spending less time on some structures than others, and skimming small sections). Cognitive Debugging™ and Speed Debugging™ is characterized by an analysis of trade-offs between measures of speed and comprehension, recognizing that different types of debugging call for different speed and comprehension rates, and that those rates may be improved with practice.

Against this hypothesis about the functional utility of priming, however, is the observation that increased fluency due to priming is short-lived, whereas priming itself is at least sometimes surprisingly long-lived. Moreover, Szmrecsanyi presents corpus analyses showing that speakers are actually less likely to use primed structures when messages are more complex, counter to the expectation that momentarily easier structures should be more likely to be deployed. This effect might be due to syntactic interference from the material that creates the greater complexity, though experimental work suggests that material in and around primed constructions does not systematically influence degree of priming. Together, these observations suggest that additional accounts of syntactic priming are needed.

How are objects and events experienced as unitary when they stimulate receptors that give rise to different forms of information? How are different modes of sensory stimulation bound together? How do infants determine which sights, sounds, tastes, and smells belong together and constitute unitary events, and which are unrelated? Adults can use prior knowledge about objects and events to guide selective attention to meaningful, unitary patterns of stimu- lation. Experienced perceivers know that faces go with voices, that the sound of footsteps foretell the approach of a person, and that the breaking glass made the sharp crashing sound. How does the infant, who begins life with no prior knowledge to guide attention, make sense of this flow and focus on stimulation that is meaningful, co-herent, and relevant? What guides and constrains perceptual devel- opment and provides the foundation for the knowledge of the adult perceiver?

For example, the face and voice of a person speaking share tem- poral synchrony, rhythm, tempo, and changing intensity. By selectively attending to these amodal properties, perceivers can attend to the unitary event, the person speaking, and ignore unrelated faces and objects nearby. This selectivity allows perception to get started on the right track in early development, providing a foundation for learning about meaningful, unitary objects and events.