JGRASP: Difference between revisions

From Wikipedia, the free encyclopedia
Browse history interactively
← Previous edit
Content deleted Content added
VisualWikitext
AnomieBOT (talk | contribs)
Bots
6,261,144 edits
m Dating maintenance tags: {{Cleanup-PR}}
m Latest version update and update to reflect new viewer support in Kotlin
 
(10 intermediate revisions by 6 users not shown)
Line 1: Line 1:
{{Infobox Software
{{Infobox Software
| screenshot = JGRASP software logo.png
| logo = JGRASP software logo.png
| screenshot = JGRASP screenshot.png
⚫
| name = jGRASP
| caption = jGRASP running on [[Windows XP]]
⚫
| developer = [http://jgrasp.org/team.html jGRASP Team]
⚫
| name = jGRASP
⚫
| latest_release_version = 2.0.6_02
⚫
| developer = [http://jgrasp.org/team.html jGRASP Team]
⚫
| latest_release_date = January 29, 2020
⚫
| latest_release_version = 2.0.6_12
| operating_system = [[Cross-platform]]
⚫
| latest_release_date = December 21, 2022
⚫
| genre = [[Integrated development environment|Java IDE]]
| platform = [[Java SE]]
⚫
| license = [http://jgrasp.org/license.html License], [[freeware]]
⚫
| genre = [[Integrated development environment|Java IDE]]
⚫
| website = http://www.jgrasp.org/
⚫
| license = [http://jgrasp.org/license.html License], [[freeware]]
⚫
| website = http://www.jgrasp.org/
}}
}}
{{lowercase|title=jGRASP}}
{{lowercase|title=jGRASP}}
Line 16: Line 18:
The runtime data structure visualizations are also available as plugins for IntelliJ IDEA, Android Studio, and Eclipse.
The runtime data structure visualizations are also available as plugins for IntelliJ IDEA, Android Studio, and Eclipse.


jGRASP is implemented in [[Java (programming language)|Java]], and runs on all platforms with a [[Java Virtual Machine]] (Java version 1.6 or higher).
jGRASP is implemented in [[Java (programming language)|Java]], and runs on all platforms with a [[Java Virtual Machine]] (Java version 1.8 or higher). GRASP (Linux, UNIX) and pcGRASP (Windows) are written in C/C++, whereas jGRASP is written in Java (the "j" in jGRASP means it runs on the JVM). The jGRASP web site offers downloads for [[Microsoft Windows|Windows]], [[Mac OS]], and as a generic [[ZIP (file format)|ZIP]] file suitable for [[Linux]] and other systems.
GRASP (Linux, UNIX) and pcGRASP (Windows) were written in C/C++, whereas jGRASP is written in Java. The "j" in jGRASP essentially means it runs on the JVM.
The jGRASP web site offers downloads for [[Microsoft Windows|Windows]], [[Mac OS]], and as a generic [[ZIP (file format)|ZIP]] file suitable for [[Linux]] and other systems.


For languages other than Java, jGRASP is a [[source code editor]]. It can be configured to work with most free and commercial compilers for any programming language.
For languages other than Java and Kotlin, jGRASP is a [[source code editor]] and basic IDE. It can be configured to work with most free and commercial compilers for any programming language.


==Visualizations==
==Visualizations==
{{Cleanup-PR|section|date=June 2020}}The [[Control Structure Diagram]]<ref>"[http://www.sigada.org/conf/sa98/papers/hendrix.pdf Visual Support for Incremental Abstraction and Refinement in Ada 95]"</ref><ref>"[http://www.jgrasp.org/papers/crosstalk.1996_1_csd.pdf GRASP/Ada 95: Visualization with Control Structure Diagrams]"</ref> (CSD) is a control flow diagram that fits into the space normally taken by indentation in source code. Its purpose is to improve the readability of source code. jGRASP produces CSDs for Java, [[C (programming language)|C]], [[C++]], [[Objective-C]], [[Ada (programming language)|Ada]], and [[VHDL]]. CSDs in jGRASP are integrated into the source code editing windows, and can be regenerated on demand. They are generated at a speed that makes the process effectively instantaneous (50,000 [[lines of code|loc]] per second or faster on modern hardware). The editing window provides CSD-based [[code folding|folding]] and a "context hint" feature that displays the first line of a code structure that is off-screen when the mouse is hovered over its CSD structure.
The [[Control Structure Diagram]]<ref>"[http://www.sigada.org/conf/sa98/papers/hendrix.pdf Visual Support for Incremental Abstraction and Refinement in Ada 95]"</ref><ref>"[http://www.jgrasp.org/papers/crosstalk.1996_1_csd.pdf GRASP/Ada 95: Visualization with Control Structure Diagrams]"</ref> (CSD) is a control flow diagram that fits into the space normally taken by indentation in source code. Its purpose is to improve the readability of source code. jGRASP produces CSDs for Java, [[C (programming language)|C]], [[C++]], [[Objective-C]], [[Ada (programming language)|Ada]], and [[VHDL]]. The editing window provides CSD-based [[code folding|folding]] and a "context hint" feature that displays the first line of a code structure that is off-screen when the mouse is hovered over its CSD structure.


The Java object viewers<ref>"[http://jgrasp.org/papers/sigcse2007paper.fp204-cross.pdf Dynamic Object Viewers for Data Structures]"</ref><ref>"[http://jgrasp.org/papers/sigcse2004paper.hendrix.cross.barowski.pdf An Extensible Framework for Providing Dynamic Data Structure Visualizations in a Lightweight IDE]"</ref> in jGRASP provide interface-based, structural, and other views of [[data structures]] and other objects and primitives during debugging and workbench operations. Often these views are more useful than the traditional tree view showing the fields of each object. For example, a content-based view shows ArrayList and LinkedList in an identical way, as a list of elements. Structural views show the internal structure of [[tree (data structure)|trees]], [[linked lists]], [[hash tables]], etc. Structural views of linked data structures display local variable nodes and their relation to the main structure. The result is animated when changes occur, as when a node is added to a linked list. In data structure viewers, one element or sub-element, such as an element of a linked list or a key or value in a hash table, may be selected and will be displayed in a "sub viewer", or they can be dragged out as separate viewers. Common data structures are automatically identified and displayed structurally. Other viewers show, for example, a [[Color swatch (UI)|color swatch]] for a Color, the image for an icon, and the binary details of a double. Multiple viewers can be combined on a single viewer canvas window and the contents can be saved to file.
The Java/Kotlin object viewers<ref>"[http://jgrasp.org/papers/sigcse2007paper.fp204-cross.pdf Dynamic Object Viewers for Data Structures]"</ref><ref>"[http://jgrasp.org/papers/sigcse2004paper.hendrix.cross.barowski.pdf An Extensible Framework for Providing Dynamic Data Structure Visualizations in a Lightweight IDE]"</ref> in jGRASP provide interface-based, structural, and other views of [[data structures]] and other objects and primitives during debugging and workbench operations. For example, a content-based view shows ArrayList and LinkedList in an identical way, as a list of elements. Structural views show the internal structure of [[tree (data structure)|trees]], [[linked lists]], [[hash tables]], etc. Structural views of linked data structures display local variable nodes and their relation to the main structure. The result is animated when changes occur, as when a node is added to a linked list. Common data structures are automatically identified and displayed structurally. Other viewers show, for example, a [[Color swatch (UI)|color swatch]] for a Color, the image for an icon, and the binary details of a double. Multiple viewers can be combined on a single viewer canvas window and the contents can be saved to file.


The Complexity Profile Graph<ref>"[http://www.jgrasp.org/papers/crosstalk.1997_12_cpg.pdf Visualization and Measurement of Source Code]"</ref> (CPG) is a unique statement-level complexity diagram. Its purpose is to aid in identifying overly complex areas of source code. jGRASP generates CPGs for both Java and Ada. The metric includes common measures, such as [[reachability]] and content complexity, which can be displayed individually. The CPG is integrated with the editing window in jGRASP so that highlighting a section of CPG will highlight the corresponding section of source code, and vice versa. They also scroll together, and the current visible portion of the editing window is shown in the CPG window.
The Complexity Profile Graph<ref>"[http://www.jgrasp.org/papers/crosstalk.1997_12_cpg.pdf Visualization and Measurement of Source Code]"</ref> (CPG) is a statement-level complexity diagram. Its purpose is to aid in identifying overly complex areas of source code. jGRASP generates CPGs for both Java and Ada. The metric includes common measures, such as [[reachability]] and content complexity, which can be displayed individually.


jGRASP also generates [[Unified Modeling Language|UML]] diagrams for Java. The UML diagrams are augmented with much interactive functionality. Clicking on a dependency edge, for example, will display all of the dependencies between two classes in a separate pane. From that pane, the source code locations of the references that cause each dependency can be listed and visited.
jGRASP also generates [[Unified Modeling Language|UML]] diagrams for Java, with interactive dependency information.


==History==
==History==

Latest revision as of 19:01, 22 December 2023

jGRASP
Developer(s)jGRASP Team
Stable release
2.0.6_12 / December 21, 2022
PlatformJava SE
TypeJava IDE
LicenseLicense, freeware
Websitehttp://www.jgrasp.org/


jGRASP is a development environment that includes the automatic creation of software visualizations. It produces static visualizations of source code structure and visualizations of data structures at runtime.[1]

The runtime data structure visualizations are also available as plugins for IntelliJ IDEA, Android Studio, and Eclipse.

jGRASP is implemented in Java, and runs on all platforms with a Java Virtual Machine (Java version 1.8 or higher). GRASP (Linux, UNIX) and pcGRASP (Windows) are written in C/C++, whereas jGRASP is written in Java (the "j" in jGRASP means it runs on the JVM). The jGRASP web site offers downloads for Windows, Mac OS, and as a generic ZIP file suitable for Linux and other systems.

For languages other than Java and Kotlin, jGRASP is a source code editor and basic IDE. It can be configured to work with most free and commercial compilers for any programming language.

Visualizations[edit]

The Control Structure Diagram[2][3] (CSD) is a control flow diagram that fits into the space normally taken by indentation in source code. Its purpose is to improve the readability of source code. jGRASP produces CSDs for Java, C, C++, Objective-C, Ada, and VHDL. The editing window provides CSD-based folding and a "context hint" feature that displays the first line of a code structure that is off-screen when the mouse is hovered over its CSD structure.

The Java/Kotlin object viewers[4][5] in jGRASP provide interface-based, structural, and other views of data structures and other objects and primitives during debugging and workbench operations. For example, a content-based view shows ArrayList and LinkedList in an identical way, as a list of elements. Structural views show the internal structure of trees, linked lists, hash tables, etc. Structural views of linked data structures display local variable nodes and their relation to the main structure. The result is animated when changes occur, as when a node is added to a linked list. Common data structures are automatically identified and displayed structurally. Other viewers show, for example, a color swatch for a Color, the image for an icon, and the binary details of a double. Multiple viewers can be combined on a single viewer canvas window and the contents can be saved to file.

The Complexity Profile Graph[6] (CPG) is a statement-level complexity diagram. Its purpose is to aid in identifying overly complex areas of source code. jGRASP generates CPGs for both Java and Ada. The metric includes common measures, such as reachability and content complexity, which can be displayed individually.

jGRASP also generates UML diagrams for Java, with interactive dependency information.

History[edit]

jGRASP was created by James Cross and Larry Barowski at the Department of Computer Science and Software Engineering in the Samuel Ginn College of Engineering at Auburn University. It is maintained and evaluated by the jGRASP Team. The development of jGRASP has been supported by a research grant from the National Science Foundation.

The development of previous versions of GRASP was supported by research grants from NASA Marshall Space Flight Center, the Department of Defense Advanced Research Projects Agency (DARPA), and the Defense Information Systems Agency (DISA).

See also[edit]

References[edit]

  1. ^ "jGRASP Home Page". www.jgrasp.org. Retrieved 2020-06-01.
  2. ^ "Visual Support for Incremental Abstraction and Refinement in Ada 95"
  3. ^ "GRASP/Ada 95: Visualization with Control Structure Diagrams"
  4. ^ "Dynamic Object Viewers for Data Structures"
  5. ^ "An Extensible Framework for Providing Dynamic Data Structure Visualizations in a Lightweight IDE"
  6. ^ "Visualization and Measurement of Source Code"

External links[edit]

Retrieved from "https://en.wikipedia.org/w/index.php?title=JGRASP&oldid=1191307108"