I got the .Net Demon trial from RedGate and it seemed to be working great, but I just realized a PostSharp aspect I'm using is being ignored and I'm not sure why... wondering if it has to do with the fact that they both do stuff with the build system.
Is anyone else using them together successfuly? I'd like to buy .Net Demon, but not if my PostSharp stuff won't work, of course. Not sure if it's related or not yet though.
We (SharpCrafters) do not officially support .NET Demon. Since Demon is an incremental compiler and PostSharp does not support incremental compilation (it compiles the whole assembly every time), I doubt it could work and, if it worked, I doubt it would have any effect on performance. Since the build time is typically dominated by PostSharp, reducing the time of the C# compiler would not significantly reduce your complete build time.
.NET Demon compiles the whole assembly each time it compiles, including any post-build steps that are in the .csproj. I don't see why it shouldn't work. Look in the build output to see whether any logging normally produced by PostSharp is there.
Related
While looking for a way to improve compile times on our build server, I came across this issue about overhead added by the incremental compiler. Since our build server checks out a fresh copy of the source and builds from scratch each time, it would be nice to be able to disable the incremental compiler completely and not have to pay for something that will not be used. Is this possible?
Grzegorz says in #1078:
The original numbers I got back in January were wrong because I was using hacked version of incremental compiler for benchmarks. I gathered more numbers using sbt 0.13.2 and the overhead of incremental compiler [snip] As you can see, for all projects apart from Scala itself, the overhead is below 10%.
So the case was closed as invalid. Related, Ability to disable incremental compiler for CI builds was closed as won't-fix.
Is this possible?
The here answer is, no (we might be open to pull reqs).
There is a relatively-new lightweight JVM called Avian that can produce executables for iOS targets.
There isn't too much documentation on the website (and not much can be found searching with Google). I was wondering if anybody was aware of a step-by-step tutorial on how to get a basic Scala program running on iOS, using Avian.
Another alternative JVM to iOS compiler is RoboVM. Although it is at an early stage, it looks quite promising, with examples on how to compile Scala for iOS.
EDIT This was an old answer, valid at that time, but, as #JamesMoore points out, RoboVM is no more. What looks very promising now, and may well be the way to run Scala code in iOS in the near future is Scala Native
Compiled Scala sources are completely standard class files. You should be able to follow the instructions (look for “Embedding”) on the website without large changes, just treat scala-library.jar as a dependency of your code.
I managed to bootstrap the complete compiler and the standard library running on Avian a few days ago.
Some parts might still be a bit rough around the edges, e. g. there is one mandatory fix which will be part of the next release of Scala (2.10.1) but is not in 2.10.0. If you want to play with it right now, you need to use a nightly build until 2.10.1 is released.
If you encounter any additional issues, please report them!
I may not need it anymore, now that Oracle is making JavaFX open-source on iOS and Android!
EDIT: Oracle updated the article to announce that they will not release a JVM, so it looks like JavaFX+Avian may be the way to go.
Running Java byte code on iOS (not-rooted) is not only running that or those JVM. As far as I understand iOS memory management doesn't allow executable memory pages to be writable in user mode. That basically prohibits any JIT compilation.
So even if it's possible to run some compiled (either from Java or Scala) classes on specific Java VM I would carefully check how this VM supports Ahead-Of-Time compilation in order to be runnable on iOS.
As I have seen Avian AOT works well on a desktop. For iOS you will have to check it yourself, although the project looks promising in AOT area.
I've looked at Microsoft's MSDN and all around the web, but I still haven't been able to get a really good idea of what it is.
Does it mean the completed program loads DLLs at different times during its execution, as apposed to all at once upon launch?
Am I totally way off? :)
Linking involves packaging together all of the .obj files built from your source files, as well as any .lib files you reference, into your output (eg .exe or .dll).
Without incremental linking, this has to be done from scratch each time.
Incremental linking links your exe/dll in a way which makes it easier for the linker to update the existing exe/dll when you make a small change and re-compile.
So, incremental linking just makes it faster to compile and link your project.
The only runtime effect it might have is that it may make your exe/dll slightly bigger and slower, as decribed here:
http://msdn.microsoft.com/en-us/library/4khtbfyf.aspx
Edit: As mentioned by Logan, incremental linking is also incompatible with link time code generation - therefore losing a possible performance optimization.
You may want to use incremental linking for debug builds to speed development, but disable it for release builds to improve runtime performance.
Delay loaded DLLs may be what you are thinking of:
http://msdn.microsoft.com/en-us/library/151kt790.aspx
Also, quite importantly, incremental link is a prerequisite for Edit&Continue - possibily to edit your code and recompile it on the fly, without restarting.
So it is a good thing to have on debug builds, but not release builds.
I like Nant very much. I do a lot of scripting with NAnt. It is a great little tool.
Since NAnt is pre 1.0, when problems occur, I often think if that it is a problem with NAnt itself, but this is not always the case.
One funny example: After running the oracle scripts I parsed the log output to make sure there was no problem. I was testing this with a small log file and it was fine.
I used the task to load the file contents to a string property and used a regex to search for errors.
When I used this script for a large log file, I stopped getting the "build failed" message at the bottom, because I was printing the error messages.
Because the "build failed" was hiding at the top, I thought NAnt crashed, but it worked fine.
It would be better for NAnt to have a 1.0 release. Any reasons why not?
NAnt is an open source project that has been around a long while and is quite stable. While they have their reasons for not calling it version "1", does the version number really matter that much in this case? It's just a label.
I'd contact the team and find out what needs to be done before they label it as such and perhaps you can contribute some bug fixes etc...
The nice thing about the source being open is if you find a bug, you can fix it yourself. Hence the risk of it not being 1.0 is mitigated slightly if you're willing to invest a bit of time.
Not sure if it matters... See the official blog - NAnt’s not dead, it was just resting
https://sourceforge.net/apps/wordpress/nant/2010/04/05/nants-not-dead-it-was-just-resting/
Open Source projects tend to use more "modest" versions than commercial products which tend to be more marketing driven. A good example of the difference is the Java versioning scheme which went from 1.0 to 1.4 and then by the time it got to version 1.5 it flipped to using version 5 (though 1.5 is the internal name).
I've used the MIT Continuous testing plugin in the past, but it has long since passed out of date and is no longer compatible with anything approaching a modern release of Eclipse.
Does anyone have a good replacement? Free, naturally, is preferred.
I found that Infinitest now has an Eclipse plugin that seems to work pretty well.
There is a list in this Ben Rady article at Object Mentor: Continuous Testing Explained. Unfortunately the only Eclipse tool appears to be CT-Eclipse which is not currently maintained either.
There is also Fireworks for IntelliJ and Infinitest which is not IDE specific but also has some IntelliJ integration.
My experience is that continuous testing within the IDE can become unwieldy and distracting, so I prefer to use something like CruiseControl to do this kind of testing. One tool I have found very useful is EclEmma, which gives you a very fast coverage turnaround for your units, helping you to decide when you have finished testing a particular area of the code.
Infinitest decides what tests it wants to run. Often it runs the wrong ones. Green bar sometimes good, sometimes meaningless.
I've had good experience with infinitest on a small and simple project. I've not run into any issues with it and find it fast and helpful.
I also use Infinitest (and voted for one of its answers), but I wanted to add another approach, which relies on the build server. Whenever you want to implement something, create a branch in your VCS, do your changes, commit to your branch. If you have a build server configured, which runs unit tests on every checkin, your unit tests are then run on the build server without actually having polluted the trunk (or HEAD, whatever you call it) and without you waiting for the test run to finish.
I admit that this is not really continuous unit testing in the sense you asked the question, but for large projects or large test suites even a "normal" continuous test runner may slow you down way to much.
For small projects I also recommend Infinitest or CT Eclipse.