Skip to content

Scala Compiler

Writing a compiler is probably one of the most complex tasks a software engineer can be tasked with – very much like slaying a dragon. The only tasks more complicated than writing a compiler is writing a dynamic runtime compiler (Sun’s Hotspot) or a writing a compiler for a programming language (Scala) that is extended and experimented with by an ever growing academic and business community. The complexity in such an undertaking is rarely confined to the source code. In fact understanding the runtime execution behavior can be just as challenging. Trying to continuously optimize and manage its performance across an unknown population set is a near impossible task (at least for us the mortals in the engineering community).

When faced with enormous complexity an engineer looks to simplify and then automate removing himself from the equation as much as possible. This is happening in the cloud today with the DevOps (and now NoOps) movement. Whilst this is a good strategy it can be a problem when such systems fail and engineers are given back control because the machine has not matched the situation to a previous behavioral pattern (or signal) and a set of remediation actions. Without a prior understanding of the software (and system behavior) such a switch in control can very easily lead to an even more dangerous situation as the engineer acts largely in a blind manner.

We rarely can manage that which we don’t understand which is why in the software performance engineering (SPE) process knowledge acquisition is an important objective in the early stages long before the system to be managed, in terms of performance, is deployed into production. In this 10 part series we show how the acquisition of such knowledge (software execution model) is achieved with our powerful, extensible and versatile software activity & resource metering technology.

How to analyze the performance behavior of software without actually timing the execution of methods
How to identify the main execution path ways and perimeters in a very large and complex code base
How to identify the major execution phases within a software’s execution of a request, task or job
How to effectively profile software balancing coverage, comprehension, integrity and validity
How to eliminate noise or redundant data from a performance model whilst controlling overhead
How to manage performance measurement costs via inline optimizations and budget control
How to identify particular execution performance outliers assessing differences and similarities
How to measure a common cause of latency slowdowns using polling and alternative candidate measures
How to introspect a metered software execution post the completion of a performance test
How to apply continuous performance management to software activity metering