Benefits of Pattern-Aware Compiler Extensions
Pattern-aware programming extends conventional object-oriented programming with a concept of pattern, which becomes a first-class element of the programming language.
Most mainstream programming languages can be extended with a concept of pattern, avoiding the cost of rewriting applications in a new language.
Because patterns are supported by the compiler extension (100% compatible with your existing compiler), they do not need to be manually implemented as boilerplate code. Features such as INotifyPropertyChanged, logging, and transactions are implemented in a cleaner, more concise way, making development and maintenance much easier.
There are 4 reasons to consider using a pattern-aware compiler extension:
Fewer lines of code means fewer hours of work. Patterns are repetitive, with little or no decision left to the developer. However, repetition is exactly what computers are good at. Let the compiler do the repetitive work and save development time and costs immediately.
Cleaner code means fewer defects. With a pattern-aware compiler eliminating the boilerplate, your code becomes easier to read, understand and modify, and contains fewer defects.
Reliability becomes much more affordable. Because they no longer require so much manual coding, reliability features such as caching or exception handling are much easier and cheaper to implement, so you can spend your extra time building a more robust app.
Cleaner and shorter code is easier to understand. After the initial release, too much development time is spent reading and analyzing source code, especially if the initial developer left. With minimized boilerplate code, developers can easily focus on business logic and spend much less time trying to understanding the code.
Better architecture is future-proof. Using a pattern-aware compiler, features like logging, exception handling or transactions are no longer scattered among thousands of files but they are defined in one place, making it much easier and fast to modify when necessary.
Achieve a better division of labor. Using a pattern-aware compiler makes the introduction of new or junior team members less onerous since they can focus on simpler, more business logic-oriented tasks rather than having to waste so much time learning complex architectural structures.
Implement a tighter feedback loop. A pattern-aware compiler can validate that handwritten code respects a pattern or a model, and it can detect bugs at build time instead of during code reviews, testing, or in production.