Let’s go inside the community version of Intellij IDEA using JArchitect<\/a>, and discover some internal design choices.<\/p>\n 1- Modularity<\/strong><\/p>\n Intellij IDEA is modularized using many projects; the main one is “idea”. The utility classes are implemented in the “util” project and the “openapi” jar contains the types needed to develop the Intellij IDEA plugins.<\/p>\n Here’s the list of the Intellij IDEA projects, and some statistics about their types:<\/p>\n Each project contains many packages to modularize its code base and the Package-by-feature approach is adopted.<\/span><\/p>\n Package-by-feature uses packages to reflect the feature set. It places all items related to a single feature (and only that feature) into a single directory\/package. This results in packages with high cohesion and high modularity, and with minimal coupling between packages. Items that work closely together are placed next to each other.<\/p>\n Here are for example some packages from the idea project, which show that the types are grouped by feature.<\/p>\n <\/p>\n 2-The Intellij IDEA developers use widely the GoF Design Patterns<\/strong><\/p>\n Design Patterns are a software engineering concept describing recurring solutions to common problems in software design. GoF patterns are the most popular ones.<\/p>\n The Intellij IDEA\u00a0developers use extensively\u00a0the GOF patterns; here are\u00a0some of them used in the source code.<\/p>\n 2-1 Factory<\/em><\/p>\n Using factory is interesting to isolate the instantiation logic and enforce the cohesion; here is the list of factories defined in the source code:<\/p>\n <\/p>\n Many factories are implemented; here are some of them inheriting from the TextEditorHighlihtingPassFactory.<\/p>\n 2-2 Adapter<\/em><\/p>\n Adapter pattern works as a bridge between two incompatible interfaces. This type of design pattern comes under structural pattern as this pattern combines the capability of two independent interfaces.<\/p>\n Many adapters are implemented in the Intellij IDEA source code:<\/p>\n 2-3 Decorator<\/em><\/p>\n The decorator pattern can be used to extend (decorate) the functionality of a certain object<\/span>\u00a0without altering its structure. Many decorators are implemented in Intellij IDEA.<\/p>\n 2-4 Proxy<\/em><\/p>\n A proxy, in its most general form, is a class functioning as an interface to something else.<\/p>\n Here’s for example the use of two proxies VirtualMachineProxy and StackFrameProxy by the classes FieldBreakpoint and FrameVariablesTree. The VirtualMachineProxy interface is used instead of the implementation. However, it’s not the case of the StackFrameProxyImpl which is coupled to FrameVariablesTree. Maybe a refactoring to remove this dependency is suitable.<\/p>\n 2-5 Facade<\/em><\/p>\n Facade pattern hides the complexities of the system and provides an interface to the client using which the client can access the system. Here’s an\u00a0example of the CodeStyle facade implemented in Intellij IDEA.<\/p>\n 2-6 Visitor<\/em><\/p>\n The\u00a0visitor design pattern\u00a0is a way of separating an\u00a0algorithm\u00a0from an object structure on which it operates.<\/p>\n The highlighting feature is implemented using a visitor pattern.<\/p>\n 2-7 Strategy<\/em><\/p>\n There are common situations when classes differ only in their behavior. In these\u00a0cases, it is a good idea to isolate the algorithms in separate classes in order to have the ability to select different algorithms at runtime.<\/p>\n Many classes implement the strategy pattern in the Intellij IDEA source code:<\/p>\n 2-8 Builder<\/em><\/p>\n This pattern allows a client object to construct a complex object; The ConrtolFlowBuilder is one of the builders implemented in Intellij IDEA source code.<\/p>\n Here are the methods called by the ControlFlowBuilder.build method:<\/p>\n 3- Coupling\u00a0<\/strong><\/p>\n Low coupling is desirable because a change in one area of an application will require fewer changes throughout the entire application. In the long run, this could alleviate a lot of time, effort, and cost associated with modifying and adding new features to an application. Many interfaces and abstract classes are defined in Intellij IDEA to enforce the low coupling:<\/p>\n <\/p>\n And here’s in blue the distribution in the Metric View\u00a0of these types in the source code.<\/p>\n In the Metric View, the code base is represented through a Treemap. Treemapping is a method for displaying tree-structured data by using nested rectangles. The tree structure used \u00a0is the usual code hierarchy:<\/p>\n The treemap view provides a useful way to represent the result of a CQLinq request; the blue rectangles represent this result, so we can visually see the types concerned by the request.<\/p>\n As we can observe the interfaces and abstract classes are defined in almost all packages, which is useful to present the features provided by a package as contracts.<\/p>\n 4- Cohesion<\/strong><\/p>\n The single responsibility principle states that a class should not have more than one reason to change. Such a class is said to be cohesive. A high LCOM value generally pinpoints a poorly cohesive class. There are several LCOM metrics. The LCOM takes its values in the range [0-1]. The LCOM HS (HS stands for Henderson-Sellers) takes its values in the range [0-2]. A LCOM HS value highest than 1 should be considered alarming. Here are \u00a0to compute LCOM metrics:<\/p>\n LCOM = 1 \u2013 (sum(MF)\/M*F) Where:<\/p>\n The underlying idea behind these formulas can be stated as follow: a class is utterly cohesive if all its methods use all its instance fields, which means that sum(MF)=M*F and then LCOM = 0 and LCOMHS = 0.<\/span><\/p>\n LCOMHS value higher than 1 should be considered alarming.<\/p>\n <\/p>\n Only very few types could be considered as not cohesive.<\/p>\n 5- Multithreading and concurrency<\/strong><\/p>\n To make the Intellij IDEA more reactive, many threads are created which improves the user experience .<\/p>\n Let’s search for all methods starting directly or indirectly threads:<\/p>\n The concurrency logic is isolated in the following packages:<\/p>\n And to facilitate the concurrency development the JSR166<\/a> is used.<\/p>\n Here’s the list of all the types used from the jsr166 jar:<\/p>\n <\/p>\n 6- Abstractenss\u00a0vs\u00a0Instability graph<\/strong><\/p>\n The idea behind this graph is that the more a code element of a program is popular, the more it should be abstract. Or in other words, avoid depending too much directly on implementations, depend on abstractions instead. By popular code element I mean a project (but the idea works also for packages and types) that is massively used by other projects of the program.<\/p>\n It is not a good idea to have concrete types very popular in your code base. This provokes some Zones of Pains in your program, where changing the implementations can potentially affects a large portion of the program. And implementations are known to evolve more often than abstractions.<\/p>\n The main sequence line (dotted) in the below\u00a0diagram shows how abstractness and instability should be balanced. A stable component would be positioned on the left. If you check the main sequence you can see that such a component should be very abstract to be near the desirable line \u2013 on the other hand, if its degree of abstraction is low, it is positioned in an area that is called the \u201czone of pain\u201d.<\/p>\n Only util is in the zone of pain, which is not really problematic. Indeed, in general an utility library \u00a0provides more some utility classes than features defined by interfaces.<\/p>\n 7- Open API and plugin system<\/strong><\/p>\n The use of plugins allows you to extend the\u00a0Intellij IDEA. The “openapi” jar is provided to achieve this goal.<\/p>\n The openapi jar provides many interfaces that represent all the features we can use and extend from our plugins.<\/p>\n An Intellij IDEA plugin contains one or many actions; many thousands of actions are implemented in the source code as shown by this following CQLinq query:<\/p>\n Exploring an existing implemented action could help developers to develop easily their custom\u00a0plugins.<\/p>\n 8- Improve performance using cache<\/strong><\/p>\n Using a\u00a0cache<\/i>\u00a0is a popular way to optimize your application.\u00a0Intellij IDEA uses two cache managers:<\/span><\/p>\n The CacheManager interface is used by the FindInProjectTask to search for words.<\/p>\n Here is the list of all methods called by FindInProjectTask.getFilesForFastWordSearch method:<\/p>\n 9- External libraries used<\/strong><\/p>\n Intellij IDEA uses many external jars, here’s the list of all the jars used: When external libs are used, it\u2019s better to check if we can easily change a third party lib by another one without impacting the whole application. There are many reasons that can encourage us to change a third party lib. The other lib could:<\/p>\n Let’s discover if some external libs are highly coupled or not.<\/p>\n Swing:<\/em><\/p>\n Swing implements a set of components for building graphical user interfaces (GUIs) and adding rich graphics functionality and interactivity to Java applications. The Swing components are implemented entirely in the Java programming language. The pluggable look and feel lets you create GUIs that can either look the same across platforms\u00a0or\u00a0can assume the look and feel of the current OS platform (such as Microsoft Windows, Solaris\u2122 or Linux).<\/p>\n Let’s search for all types using directly swing components:<\/p>\n Many types use directly swing components as shown by the following treemap which shows in blue these types.<\/p>\n It’s not easy to change swing by another Gui framework. And even\u00a0if Swing is\u00a0\u00a0a subject of controversy, the amazing GUI of Intellij IDEA proves that Swing is a good choice for Gui needs.<\/span><\/p>\n Netty:<\/em><\/p>\n Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients.<\/p>\n Here’s the list of all types using this library:<\/p>\n Only some few types use it directly, which is very useful if we want to change it with another library.<\/p>\n ASM:<\/em><\/p>\n ASM<\/span>\u00a0is a very small and very fast Java bytecode manipulation framework. It becomes very popular, many tools use it. We used it also in our tool JArchitect to analyse the bytecode.<\/span><\/p>\n Here’s the list of all types using ASM directly:<\/p>\n As Netty , the use of ASM is isolated in some packages, and we can change it easily.<\/p>\n Except Swing almost all other external jars are not highly coupled to Intellij IDEA.<\/p>\n 10- Statistics<\/strong><\/p>\n 10-1 Most used type<\/p>\n It\u2019s interesting to know the most used types in a project; indeed these types must be well designed, implemented and tested. And any change occurs to them could impact the whole project.<\/p>\n We can find them using the\u00a0TypesUsingMe<\/em>\u00a0metric:<\/p>\n However, there\u2019s another interesting metric to search for popular types: TypeRank.<\/p>\n TypeRank values are computed by applying the\u00a0Google PageRank<\/a>\u00a0algorithm on the graph of types\u2019 dependencies. A homothety of center 0.15 is applied to make it so that the average of TypeRank is 1.<\/p>\n Types with high TypeRank should be more carefully tested because bugs in such types will likely be more catastrophic.<\/p>\n Here\u2019s the result of all popular types according to the TypeRank metric:<\/p>\n With this metric PsiElement became the most used type instead of the Project interface.<\/p>\n 10-2 Most used methods:<\/p>\n![\"intellij4\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij4.png\")
<\/a><\/p>\n![\"intellij1\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij1.png\")
<\/a><\/p>\n![\"intellij3\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij3.png\")
<\/a><\/p>\n![\"intellij2\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij2.png\")
<\/a><\/p>\n![\"idea8\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/idea8.png\")
<\/a><\/p>\n![\"idea9\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/idea9.png\")
<\/a><\/p>\n![\"intellij5\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij5.png\")
<\/a><\/p>\n![\"intellij6\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij6.png\")
<\/a><\/p>\n![\"intellij7\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij7.png\")
<\/a><\/p>\n![\"intellij8\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij8.png\")
<\/a><\/p>\n![\"intellij9\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij9.png\")
<\/a><\/p>\n
\nHere are three key benefits derived from using interfaces:<\/p>\n\n
![\"intellij11\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij11.png\")
<\/a><\/p>\n![\"intellij10\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij10.png\")
<\/a><\/p>\n\n
\nLCOM HS = (M \u2013 sum(MF)\/F)(M-1)<\/p><\/blockquote>\n\n
![\"intellij12\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij12.png\")
<\/a><\/p>\n![\"intellij13\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij13.png\")
<\/a><\/p>\n![\"intellij14\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij14.png\")
<\/a><\/p>\n![\"intellij32\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij32.png\")
<\/a><\/p>\n![\"AbstractnessVSInstability\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/AbstractnessVSInstability.png\")
<\/a><\/p>\n![\"intellij24\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij24.png\")
<\/a><\/p>\n![\"intellij23\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij23.png\")
<\/a><\/p>\n![\"intellij26\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij26.png\")
<\/a><\/p>\n![\"intellij25\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij25.png\")
<\/a><\/p>\n
\n![\"intellij21\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij21.png\")
<\/a>
\n![\"intellij22\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij22.png\")
<\/a><\/p>\n\n
![\"intellij18\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij18.png\")
<\/a><\/p>\n![\"intellij16\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij16.png\")
<\/a><\/p>\n![\"intellij20\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij20.png\")
<\/a><\/p>\n![\"intellij19\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij19.png\")
<\/a><\/p>\n![\"intellij28\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij28.png\")
<\/a><\/p>\n![\"intellij27\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij27.png\")
<\/a><\/p>\n
![\"intellij30\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij30.png\")
<\/a><\/p>\n![\"intellij31\"](\"http:\/\/www.codergears.com\/Blog\/wp-content\/uploads\/intellij31.png\")
<\/a><\/p>\n