Expertiza_Wiki - User contributions [en]

Main Page/ELI demo/p1

2011-02-10T16:41:18Z

Unctlt1:

This is really my page 1.

Team2/team1

2009-03-17T01:47:26Z

Unctlt1:

==Turn-it-in and MOSS==

Protecting against plagiarism in academic work is important and many tools are available for instructors to use to verify students are not incorporating known works into their own without attribution. Turn-it-in for essays, and MOSS for software are two. Both require sending a copy of a student’s work to a central repository for it to be checked against the other works that the repository contains. The results are reported to the instructor and the student’s work is retained in the repository, adding to the body of work that future works will be checked against.

Examine the ethical considerations surrounding use of programs like Turn-it-in and MOSS.

* [http://turnitin.com/static/plagiarism.html http://turnitin.com/static/plagiarism.html]
* [http://chronicle.com/free/2008/03/2250n.htm http://chronicle.com/free/2008/03/2250n.htm]
* [http://theory.stanford.edu/~aiken/moss/ http://theory.stanford.edu/~aiken/moss/]
* [http://www.cse.nd.edu/~kwb/nsf-ufe/1110.pdf http://www.cse.nd.edu/~kwb/nsf-ufe/1110.pdf]

==MOSS==

MOSS (Measure Of Software Similarity) is a system for determining the similarity of different programs. To date, the main application of MOSS has been in detecting plagiarism in programming classes. Since its development in 1994, Moss has been very effective in this role. The algorithm behind moss is a significant improvement over other cheating detection algorithms. The system was developed by (and resides at) Stanford. The algorithm is hidden to end users, meaning users must send the batch of code to Standford's server and wait for a response.

Supported Languages:
C, C++, Java, C#, Python, Visual Basic, Javascript, FORTRAN, ML, Haskell, Lisp, Scheme, Pascal, Modula2, Ada, Perl, TCL, Matlab, VHDL, Verilog, Spice, MIPS assembly, a8086 assembly, a8086 assembly, MIPS assembly, HCL2

For more information on MOSS, visit Stanford's site at the following link: [http://theory.stanford.edu/~aiken/moss/]

==TurnItIn==

TurnItIn got its start in 1996 when a group of researchers at UC Berkeley created a series of computer programs to monitor the recycling of research papers in their large undergraduate classes. The researchers teamed with a group of teachers, mathematicians, and computer scientists to form Plagiarism.org, the world's first internet-based plagiarism detection service.

By late 1998, Plagiarism.org had become the center of international media attention. The small organization was featured in several major media venues, including Good Morning America, World News Tonight, and the New York Times. In the six years since, Plagiarism.org has continued to grow and is now recognized around the world as TurnItIn and iThenticate, the internet's most widely used and trusted resources for preventing the spread of internet plagiarism.

TurnItIn's homepage can be found at the following link: [http://turnitin.com/static/index.html]

==Plagiarism overview==
According to [http://plagiarism.org Plagiarism.org], plagiarism is "to steal and pass off (the ideas or words of another) as one's own, to use (another's production) without crediting the source, to commit literary theft, or to present as new and original an idea or product derived from an existing source." Plagiarism has always been a large problem in universities. The start of the internet made plagiarism even easier due to the large amount of material available. Many schools have very strict punishments for plagiarism. In North Carolina, plagiarism is a class 2 misdemeanor. [http://www.provost.ncsu.edu/copyright/plagiarism/#statestatute]

Plagiarism is unethical because it is an act of stealing. Plagiarism steals another writers words and takes the credit of their original thoughts away from them and giving credit to the author who took the work. Schools try very hard to teach prevention of plagiarism, but that's not always enough. That's why there are programs like TurnItIn and MOSS.

==Ethical considerations==
The act of plagiarism itself is one that is fraught with obvious ethical and moral implications but what about the software that is used to check for plagiarism? Could they too have ethical concerns that are not so obvious? In a word, Yes.

One of the main ethical concerns with MOSS and Turn-It-In is in regard to how they operate. In order to effectively check for plagiarism, they need a massive database of work to use as a basis for comparison. The only way this can be achieved is by collecting information from students and other sources on a massive scale and then in turn, using that same information to compare against future work. Whether a student likes it or not they are effectively giving a copy of their work to these companies for them to use in the advancement and betterment of their product. A product that, at least in the case of Turn-It-In, is marketed commercially and the company does in fact make money off of its use and thus are making money off of the uncredited work of students. These students are often not asked for permission to use their work, they are not paid for their contributions, and ultimately they are not even credited for their work in helping to combat plagiarism. The ethics of this practice are controversial enough that they were the subject of an unsuccessful class-action lawsuit in 2007.[http://www.washingtonpost.com/wp-dyn/content/article/2007/03/28/AR2007032802038.html] The point of the lawsuit was that public high-school students, too young to enter into a legally binding contract, were being forced to send their work to a company that would in turn use that work to increase their own profits. [http://www.plagiarismtoday.com/2008/03/25/iparadigms-wins-turnitin-lawsuit/]

Another significant ethical and moral problem with these programs is that by using them, students are being treated as if they are guilty until proven innocent and that all students are inherently cheaters. [http://notofgeneralinterest.blogspot.com/2008/02/shorter-chronicle-turnitin-spawn-of.html] This ethical dilemma is one that instructors must contend with whenever they employ such technology but the alternative, that of manually researching content, is far to time intensive in many cases to be considered a viable alternative. As a result, the use of anti-plagiarism software is not uncommon in high schools and colleges.

==Links & Sources==

*[http://theory.stanford.edu/~aiken/moss/ 1] Official Moss Homepage
*[http://turnitin.com/static/index.html 2] Official TurnItIn Homepage
*[http://plagiarism.org 3] Plagiarism.org
*[http://www.plagiarismtoday.com/2008/03/25/iparadigms-wins-turnitin-lawsuit/ 4] Plagiarism Today
*[http://www.washingtonpost.com/wp-dyn/content/article/2007/03/28/AR2007032802038.html 5] Washington Post
*[http://notofgeneralinterest.blogspot.com/2008/02/shorter-chronicle-turnitin-spawn-of.html 6] Blogspot

UNC TLT/unctlt3

2008-11-20T20:35:00Z

Unctlt1:

Hello. This is a test.
'''This is a bold sentence.'''
[[This is a hyperlinked sentence.]]
''This sentence is indented.''
wait that doesn't look indented -- it's just at the end of the prior line.

This page was last edited on November 19, 2008.

Expertiza is really ''
== '''fun''' ==''!

CSC/ECE 517 Summer 2008/wiki3 3 lc

2008-11-20T20:27:07Z

Unctlt1: /* Problem Description */

=Low Coupling=
This document seeks to explain low coupling and how exactly you may recognize the degree of coupling in your existing code. Hopefully you will then be able to integrate this concept into your own programs to reduce coupling where necessary.

==Problem Description==
We introduced the idea of low coupling in Lecture 20, and used the Observer pattern as an example in Lecture 23. But we have really only scratched the surface on what there is to know about achieving low coupling. Browse the Web and the ACM DL for other information, both theoretical and practical, and produce a guide to what there is to know about low coupling. Be sure to highlight those aspects that would be appropriate for inclusion in CSC/ECE 517.

==Coupling==
[[Image:dependency.jpg|thumb|right|150px|Figure 1: Dependency]]
Coupling, also known as dependence, is a measurement of the degree in which two program modules rely on each other to complete a task.

Recognizing dependencies:
*A member function of class A uses an object from class B.
*When making CRC cards the "collaborators" column denotes classes which depend on one another.
*As seen to the right in UML diagrams a dashed line with an open arrow points to a dependent class.

When two modules have a very stable interface between one another, one which does not require or even concern itself with the internal structure of the other module and you have "low" coupling between those modules. Other terms used to describe this situation may be "loose" or "weak" coupling.

Recognizing low coupling:
*The number of connections between classes is low and seems more like a tree structure than spaghetti code.
*Interfaces between two classes are well defined and usually only communicate through messages (independent modules)
*Changes to individual classes do not require modification to their dependent classes
*The number of dependent classes program wide are low

=== Types of Couping ===

*'''Pathological/Content Coupling''' was discussed earlier and occurs when a function of class A actually uses or modifies objects/data from class B.
*'''Global Coupling''' can be recognized by the use of global data variables to communicate between two classes. ie Keeping a count of the number of objects initialized using a global count variable.
*'''Control Coupling''' uses a control flag to send instructions between two classes, similar to the way semaphore files were used to exchange data between multiple sessions of the same MS-DOS application.
*'''Data-Structure Coupling''' occurs when a predifined amount of data must be passed between modules, much of this data may not be used but must be present to satisfy the requirements for the message to be successfully transmitted or passed.
*No Data Coupling occurs when two modules do not transfer data or interact in any way. They are said to be two independent modules.

==Benefits of Low Coupling==

===Reduced Code===
[[Image:highcoupling.jpg|thumb|right|150px|Figure 2: High Coupling]]
[[Image:lowcoupling.jpg|thumb|right|150px|Figure 3: Low Coupling]]
When a module is modified in a well-structured system, one which makes use of low couping, very few subsequent modules must be modified as a result. This has obvious benefits in regards to the speed at which changes may be implemented and subsequent testing that must be performed as a result.

'''Figure 2''' is a UML diagram which is meant to quickly display a system of classes that are highly coupled. Note the multitude of dependency arrows in the diagram. These dependencies are so numerous that any programmer would have a lot of classes to modify if just one change to the system was requested. This means that when testing any changes to the code a programmer may actually have problems in classes that were not actually modified while implementing the new code. This inherently increases the time and amount of code necessary to implement a single feature. Not to mention the testing which will be discussed more later.

'''Figure 3''' is a low coupled system which can be easily identified by the more branch like structure of the dependency arrows. Adding a feature to this system would require only a small amount of classes to be affected and thus would limit the amount of code and testing to those classes.

Code can be further reduced by simply reusing classes which have low coupling. Since they are not dependent on a lot of other classes you may use the code over and over in many different situations. Of course care must be taken that the code is not simply copied and pasted but referenced in some other means (unless you are using it in a totally different program) Code reuse is very important but not if the same code must be copied hundreds of times within the same application.

===Reduced Yo-Yo Affect===
Anytime a programmer must flip back and forth between numerous classes or files to examine code you are lowering their efficiency and increasing the amount of possible mistakes in interpreting the code. The lower the coupling the less flipping between code segments or different classes one must do to read your code. For your own future code maintenance and the sanity of anyone who may later read your code reduce the Yo-Yo affect by lowering coupling between your classes.

===Better Testing===

By lowering coupling a module may be tested without including a multitude of other classes or modules. By making testing easier programmers are more likely to thoroughly test code and less bugs will reside in the final version of the code. The test cases that must be created by the programmer will be simplified in a loosely coupled environment and in some cases the original test cases may be reused or only slightly modified to create a complete testing solution.

===Better Encapsulation===
Anytime you can hide the design details of your program so that other modules and services may utilize a standard rarely changing interface your program will be less likely to break other modules as a result of design detail modifications.

This is essential to coding a well-structured system which may grow and change to the users requests or external requirements beyond the programmers control. In the every changing workplace as soon as a program has been coding and fully tested, it seems that modifications are needed or often required.

==Consequences of Low Coupling==
[[Image:xml.jpg|thumb|right|300px|Figure 4: XML DTD]]
One of the unavoidable consequences of low coupling is reduced performance, usually reduced performance is highly tolerable when compared to the increased programming efficiency and ease of future modification. The reduced performance can result from the message handling between modules or classes. Issues such as transaction integrity, data duplication, and synchronization must be taken into consideration when creating a low coupled system. If the type of messages used is under your control it is encouraged to use a flexible file format such as XML which uses [http://www.xmlfiles.com/dtd/dtd_intro.asp '''Document Type Definitions'''] to allow for clear explanations of what type of data is included and how the data should subsequently be used.

==Design Patterns and Coupling==
Several design patterns have big implications on the coupling of your system. These use of such patterns can increase the coupling or lower it depending on how you use them. For example a great pattern for lowering coupling is the [http://java-x.blogspot.com/2007/01/implementing-observer-pattern-in-java.html '''observer pattern''']. This pattern can be used to solve the problem of objects notifying other objects of a change in their state. The solution requires the use of a central object, called the subject, which keeps a list of all objects interested in hearing about updates to one particular object. The subject knows only a list of observers that implement the observer interface and thus loose coupling between the subject and observers can be maintained. Other patterns such as the [http://wiki.rubyonrails.org/rails/pages/MVC '''Model/View/Controller'''] can be used to separate the business logic of an application from it's GUI allowing one to be modified without necessarily affecting the other. These patterns, as well as others, can be utilized to lower coupling and ensure your programs may be maintained for many years to come. For more information on these patterns as well as any other topic covered in this wiki please view the links below.

==References==
[http://javaboutique.internet.com/tutorials/coupcoh/ Java Boutique Article on Coupling and Cohesion]

[http://en.wikipedia.org/wiki/Modularity_(programming) Modular Programming]

[http://en.wikipedia.org/wiki/Information_Hiding Information Hiding]

[http://en.wikipedia.org/wiki/Information_Hiding Loose Coupling]

[http://thecomcor.blogspot.com/2008/06/low-coupling.html Blog Entry on Low Coupling]

[http://www.adobe.com/devnet/flex/articles/loose_coupling.html Loose Coupling in Flex Applications]

[http://wiki.rubyonrails.org/rails/pages/MVC Ruby's Model/View/Controller Explained]

==Tools==
[http://semmle.com/documentation/ Semmle Code Querying Tool (works with Eclipse)]

ECE633:hw1

2008-11-20T20:11:26Z

Unctlt1:

== Welcome to the first assignment of the semester! ==

Instructions:

* Create a new wiki page under this name space using your unity ID.

For example

http://pg-server.ece.ncsu.edu/mediawiki/index.php/ECE633:hw1:jthaug/

* On the page you create, write a brief biography about yourself to share with your classmates.

Please keep your entry to 500 words or less!

ECE633:hw1

2008-11-20T20:11:14Z

Unctlt1:

UNC TLT/unctlt1

2008-10-30T17:15:58Z

Unctlt1:

I am user #1.

Wiki collaboration in the classroom could be worked into the global network.

This edit is part of a demo assignment.

--- Additional Information ---

Expertiza is using MediaWiki.

UNC TLT/unctlt1

2008-08-21T14:59:17Z

Unctlt1:

I am user #1.

Wiki collaboration in the classroom could be worked into the global network.

UNC TLT/unctlt5

2008-08-21T14:58:37Z

Unctlt1:

Today is thursday, the end of August. School is starting soon and I am not really. I only have one syllabi completed, does anyone want to finish my work for me so i can go to the beach?

UNC TLT/unctlt1

2008-08-21T14:57:55Z

Unctlt1:

I am user #1.

I am wondering how wiki collaboration in the classroom can be worked into the global network.

UNC TLT/unctlt1

2008-03-07T22:30:13Z

Unctlt1:

This is another test.

UNC TLT/unctlt1

2008-03-07T22:09:43Z

Unctlt1:

This is another test.

I added then delete a line.

UNC TLT/unctlt1

2008-03-07T22:05:00Z

Unctlt1:

This is another test.

This is adam's test after modifying the LocalSettings.php file.

UNC TLT/unctlt1

2008-03-07T21:28:48Z

Unctlt1:

This is another test.