Given that Scala runs on the Java Virtual Machine (`JVM`), you can use the `JVM` tools `JConsole` and `VisualVM` to profile the application. Alternatively *any* Java profiler should work (e.g. YourKit, as you&#39;ve already mentioned)

[**`VisualVM`**][1] has been bundled with the JDK since `1.6.0_10` and it is based on the NetBeans profiler. You can capture memory usage, code performance hotspots etc:

    C:&gt; %JAVA_HOME%\bin\jvisualvm


  [1]: https://visualvm.java.net/gettingstarted.html

I have tried with jvisualvm (both inside and outside netbeans) but I cannot see any scala method call in the profiling reports (only the underlying java libraries method calls). To me it looks like a bug but I might have missed snomething obvious. Anyway here is a issue report I wrote on netbeans.org with the details:[171388][1]

If anybody here has successfully used JVisualVM to CPU-profile Scala code please let me know.


  [1]: http://www.netbeans.org/issues/show_bug.cgi?id=171388

I keep hearing that in .net 3.5 you should use IEnumerable over a List, but I can’t find any reference materials or articles that explain why it’s so much more proficient.  Does anyone know of any content that explains this? 

The purpose of asking this question is to get a better understanding of what IEnumerable is doing under the hood.  If you can provide me with any links I will do the research and post an answer. 




Explanation why IEnumerable is more efficient than a List

Can somebody please refer me to a &lt;strong&gt;comprehensive&lt;/strong&gt; tutorial on Canvas which covers all properties / functions?

I also need a definite reference on Canvas - something like w3schools

Canvas Tutorial / Reference

I started to program in Scala recently. I&#39;m looking for a free Scala profiler. Reading from the language&#39;s official site led me to [YourKit][1], but the program was not a free one.

Googling &quot;scala profiler&quot; didnt give me any relevant result.

So how do I profile my program written in Scala? I prefer a graphical plugin for Netbeans or Eclipse. But if there is no such thing, then a console one will be fine.

Thanks :)


  [1]: http://www.yourkit.com/

Scala profiler?

I started to program in Scala recently. I'm looking for a free Scala profiler. Reading from the language's official site led me to <a href="http://www.yourkit.com/" target="_blank" rel="noopener noreferrer">YourKit</a>, but the program was not a free one.
Googling "scala profiler" didnt give me any relevant result.
So how do I profile my program written in Scala? I prefer a graphical plugin for Netbeans or Eclipse. But if there is no such thing, then a console one will be fine.
Thanks :)

Is it possible to match a range of values in Scala?

For example:

    val t = 5
    val m = t match {
        0 until 10 =&gt; true
        _ =&gt; false
    }

`m` would be `true` if `t` was between 0 and 10, but false otherwise. This little bit doesn&#39;t work of course, but is there any way to achieve something like it?
        

Can a range be matched in Scala?

I have a Scala data processing tool which is failing with a `java.lang.OutOfMemoryError` exception. The tool needs to make a couple passes over a large data file (the one I&#39;m working on is over 700MB), so it would be convenient if the entire thing could be stored in memory.

I run the tool from the command line or from a Bash script using the &quot;scala&quot; runner. How do I increase the JVM heap size for this? I&#39;ve tried passing `-Xmx1024m`, but it does not recognize this argument. I&#39;m using a nightly build of Scala 2.8.0 (r18678).

Increase JVM heap size for Scala?

In Scala, what&#39;s the best way to dynamically instantiate an object and invoke a method using reflection?

I would like to do Scala-equivalent of the following Java code:

    Class class = Class.forName(&quot;Foo&quot;);
    Object foo = class.newInstance();
    Method method = class.getMethod(&quot;hello&quot;, null);
    method.invoke(foo, null);

In the above code, both the class name and the method name are passed in dynamically. The above Java mechanism could probably be used for `Foo` and `hello()`, but the Scala types don&#39;t match one-to-one with that of Java. For example, a class may be declared implicitly for a singleton object. Also Scala method allows all sorts of symbols to be its name. Both are resolved by name mangling. See [Interop Between Java and Scala][1].

Another issue seems to be the matching of parameters by resolving overloads and autoboxing, described in [Reflection from Scala - Heaven and Hell][2].  

  [1]: http://www.codecommit.com/blog/java/interop-between-java-and-scala
  [2]: http://www.familie-kneissl.org/Members/martin/blog/reflection-from-scala-heaven-and-hell

Scala: How do I dynamically instantiate an object and invoke a method using reflection?

In Java you can write &lt;code&gt;Boolean.valueOf(myString)&lt;/code&gt;. However in Scala, &lt;code&gt;java.lang.Boolean&lt;/code&gt; is hidden by &lt;code&gt;scala.Boolean&lt;/code&gt; which lacks this function. It&#39;s easy enough to switch to using the original Java version of a boolean, but that just doesn&#39;t seem right.

So what is the one-line, canonical solution in Scala for extracting &lt;code&gt;true&lt;/code&gt; from a string?

Scala: Elegant conversion of a string into a boolean

Where can I find a list of Scala&#39;s &quot;magic&quot; functions, such as `apply`, `unapply`, `update`, `+=`, etc.?

By magic-functions I mean functions which are used by some syntactic sugar of the compiler, for example

    o.update(x,y) &lt;=&gt; o(x) = y

I googled for some combination of `scala` `magic` and synonyms of `functions`, but I didn&#39;t find anything.

I&#39;m not interested with the *usage* of magic functions in the standard library, but in which magic functions exists.



List of Scala&#39;s &quot;magic&quot; functions

What other programs do the same thing as gprof?

Alternatives to gprof

Everyone always says to profile your program before performing optimizations but no-one ever describes how to do so.

What are your practices for profiling C code?

Recommendations for C Profilers?

I need to see the queries submitted to a PostgreSQL server.  Normally I would use SQL Server profiler to perform this action in SQL Server land, but I&#39;m yet to find how to do this in PostgreSQL.  There appears to be quite a few pay-for tools, I am hoping there is an open source variant.

Is there a PostgreSQL equivalent of SQL Server profiler?

I use [cProfile][1] now but I find it tedious to write pstats code just to query the statistics data.

I&#39;m looking for a visual tool that shows me what my Python code is doing in terms of CPU time and memory allocation.

Some examples from the Java world are [visualvm][2] and [JProfiler][3].

- Does something like this exist?
- Is there an IDE that does this?
- Would [dtrace][4] help?

I know about [KCachegrind][5] for Linux, but I would prefer something that I can run on Windows/Mac without installing KDE.


  [1]: http://docs.python.org/library/profile.html
  [2]: https://visualvm.dev.java.net/features.html
  [3]: http://www.ej-technologies.com/products/jprofiler/top10.html
  [4]: http://developer.apple.com/mac/library/documentation/DeveloperTools/Conceptual/InstrumentsUserGuide/ViewingandAnalyzingData/ViewingandAnalyzingData.html#//apple_ref/doc/uid/TP40004652-CH5-SW2
  [5]: https://stackoverflow.com/questions/1896032/using-cprofile-results-with-kcachegrind

Is there a visual profiler for Python?

I would like to know if it is possible to get a profile from `R`-Code in a way that is similar to `matlab`&#39;s Profiler. That is, to get to know which line numbers are the one&#39;s that are especially slow.

What I acchieved so far is somehow not satisfactory. I used `Rprof` to make me a profile file. Using `summaryRprof` I get something like the following:

&gt;     $by.self
&gt;                       self.time self.pct total.time total.pct
&gt;     [.data.frame               0.72     10.1       1.84      25.8
&gt;     inherits                   0.50      7.0       1.10      15.4
&gt;     data.frame                 0.48      6.7       4.86      68.3
&gt;     unique.default             0.44      6.2       0.48       6.7
&gt;     deparse                    0.36      5.1       1.18      16.6
&gt;     rbind                      0.30      4.2       2.22      31.2
&gt;     match                      0.28      3.9       1.38      19.4
&gt;     [&lt;-.factor                 0.28      3.9       0.56       7.9
&gt;     levels                     0.26      3.7       0.34       4.8
&gt;     NextMethod                 0.22      3.1       0.82      11.5
&gt;     ...

and 

&gt;     $by.total
&gt;                           total.time total.pct self.time self.pct
&gt;     data.frame                  4.86      68.3      0.48      6.7
&gt;     rbind                       2.22      31.2      0.30      4.2
&gt;     do.call                     2.22      31.2      0.00      0.0
&gt;     [                           1.98      27.8      0.16      2.2
&gt;     [.data.frame                1.84      25.8      0.72     10.1
&gt;     match                       1.38      19.4      0.28      3.9
&gt;     %in%                        1.26      17.7      0.14      2.0
&gt;     is.factor                   1.20      16.9      0.10      1.4
&gt;     deparse                     1.18      16.6      0.36      5.1
&gt;     ...

To be honest, from this output I don&#39;t get where my bottlenecks are because (a) I use `data.frame` pretty often and (b) I never use e.g., `deparse`. Furthermore, what is `[`?

So I tried Hadley Wickham&#39;s `profr`, but it was not any more useful considering the following graph:
![alt text][1]


**Is there a more convenient way to see which line numbers and particular function calls are slow?  
Or, is there some literature that I should consult?**

Any hints appreciated.

**EDIT 1:**  
Based on Hadley&#39;s comment I will paste the code of my script below and the base graph version of the plot. But note, that my question is not related to this specific script. It is just a random script that I recently wrote. **I am looking for a general way of how to find bottlenecks and speed up `R`-code.**

The data (`x`) looks like this:

&gt;     type		word	response	N	Classification	classN
&gt;     Abstract	ANGER	bitter		1	3a				3a
&gt;     Abstract	ANGER	control		1	1a				1a
&gt;     Abstract	ANGER	father		1	3a				3a
&gt;     Abstract	ANGER	flushed		1	3a				3a
&gt;     Abstract	ANGER	fury		1	1c				1c
&gt;     Abstract	ANGER	hat			1	3a				3a
&gt;     Abstract	ANGER	help		1	3a				3a
&gt;     Abstract	ANGER	mad			13	3a				3a
&gt;     Abstract	ANGER	management	2	1a				1a
&gt;     ... until row 1700

The script (with short explanations) is this:


&gt;     Rprof(&quot;profile1.out&quot;)
&gt;     
&gt;     # A new dataset is produced with each line of x contained x$N times 
&gt;     y &lt;- vector(&#39;list&#39;,length(x[,1]))
&gt;     for (i in 1:length(x[,1])) {
&gt;      	y[[i]] &lt;- data.frame(rep(x[i,1],x[i,&quot;N&quot;]),rep(x[i,2],x[i,&quot;N&quot;]),rep(x[i,3],x[i,&quot;N&quot;]),rep(x[i,4],x[i,&quot;N&quot;]),rep(x[i,5],x[i,&quot;N&quot;]),rep(x[i,6],x[i,&quot;N&quot;]))
&gt;     }
&gt;     all &lt;- do.call(&#39;rbind&#39;,y)
&gt;     colnames(all) &lt;- colnames(x)
&gt;     
&gt;     # create a dataframe out of a word x class table
&gt;     table_all &lt;- table(all$word,all$classN)
&gt;     dataf.all &lt;- as.data.frame(table_all[,1:length(table_all[1,])])
&gt;     dataf.all$words &lt;- as.factor(rownames(dataf.all))
&gt;     dataf.all$type &lt;- &quot;no&quot;
&gt;     # get type of the word.
&gt;     words &lt;- levels(dataf.all$words)
&gt;     for (i in 1:length(words)) {
&gt;     	dataf.all$type[i] &lt;- as.character(all[pmatch(words[i],all$word),&quot;type&quot;])
&gt;     }
&gt;     dataf.all$type &lt;- as.factor(dataf.all$type)
&gt;     dataf.all$typeN &lt;- as.numeric(dataf.all$type)
&gt;     
&gt;     # aggregate response categories
&gt;     dataf.all$c1 &lt;- apply(dataf.all[,c(&quot;1a&quot;,&quot;1b&quot;,&quot;1c&quot;,&quot;1d&quot;,&quot;1e&quot;,&quot;1f&quot;)],1,sum)
&gt;     dataf.all$c2 &lt;- apply(dataf.all[,c(&quot;2a&quot;,&quot;2b&quot;,&quot;2c&quot;)],1,sum)
&gt;     dataf.all$c3 &lt;- apply(dataf.all[,c(&quot;3a&quot;,&quot;3b&quot;)],1,sum)
&gt;     
&gt;     Rprof(NULL)
&gt;     
&gt;     library(profr)
&gt;     ggplot.profr(parse_rprof(&quot;profile1.out&quot;))

Final data looks like this:

&gt;     1a	1b	1c	1d	1e	1f	2a	2b	2c	3a	3b	pa	words	type	typeN	c1	c2	c3	pa
&gt;     3	0	8	0	0	0	0	0	0	24	0	0	ANGER	Abstract	1	11	0	24	0
&gt;     6	0	4	0	1	0	0	11	0	13	0	0	ANXIETY	Abstract	1	11	11	13	0
&gt;     2	11	1	0	0	0	0	4	0	17	0	0	ATTITUDE	Abstract	1	14	4	17	0
&gt;     9	18	0	0	0	0	0	0	0	0	8	0	BARREL	Concrete	2	27	0	8	0
&gt;     0	1	18	0	0	0	0	4	0	12	0	0	BELIEF	Abstract	1	19	4	12	0

The base graph plot:
![alt text][2]

[Running the script today also changed the ggplot2 graph a little (basically only the labels), see here.][3]


  [1]: http://i.stack.imgur.com/YIm0J.png
  [2]: http://i.stack.imgur.com/FtbVh.png
  [3]: http://imgur.com/8grk7.png

Content Type	Original Author	Original Content on Stackoverflow
Question	Phil	View Question on Stackoverflow
Solution 1 - Scala	oxbow_lakes	View Answer on Stackoverflow
Solution 2 - Scala	ogrisel	View Answer on Stackoverflow

Scala profiler?

Scala Problem Overview

Scala Solutions

Solution 1 - Scala

Solution 2 - Scala

Canvas Tutorial / Reference

Explanation why IEnumerable is more efficient than a List

Attributions