There are many reasons why experienced programmers choose to write assembler code, performance issues where speed matters, the architectural freedom to lay out code in any way you like, the capacity to do things that cannot be done in many compilers but the main reason is simply because you can. Many conjure up the image of cobbling together a few DOS interrupts in unintelligible notation to prop up the shortcomings of compilers yet a modern assembler like MASM has the range of a high level language and can be written that way for high level code while retaining all of its power at the lowest level.

With the introduction of the 32 bit Windows API functions, MASM had access at the same functions that compilers had from the operating system but without the clutter and assumption of many of the compilers available. When you write Windows API code in MASM you get perfectly clear minimal precision code that leverages the full power of the Windows operating system and you get it at the code size you write, not with a pile of unwanted extras dumped into your executable by a compiler.

MASM has never been for the faint of heart, it is an uncompromised tool that has never been softened into a user friendly toy and it required the development of expertise to use correctly but for the programmer who already has experience in low level C and similar code, MASM offers power and flexibility that the best of compilers cannot deliver and contrary to popular opinion it can be developed and written at about the same development time as C code.

MASM handle C style structures with ease as it does with a number of other familiar high level constructions.

Instead of the nightmares of old with unreadable and unmaintainable code, the high level aspects of MASM look and read very much like traditional C code yet at any time it can work directly in mnemonics where performance matters.

Window API calls are clean clear code.

Where genuine performance matters loop code is written directly in mnemonics using any of the entire instruction set that the processor will support and you are by no means restricted to high level style loop code or the theory behind it. You can write multi-entry and exit loops, nested loops, interdependent loops and manually unrolled loops of many different designs, most of which will give even the best compilers nightmares.

Block structure conditional testing is routine in MASM with an efficient and clear notation that is useful in all but the most demanding algorithms where direct mnemonic code can bypass unrequired structure for maximum performance.

This combined capacity alone makes MASM a formidable tool yet its true designation is that of a MACRO assembler, a capacity that few would be familiar with and it has a very powerful pre-processor that substantially extends this already formidable capacity. MASM macros are known to be quirky and at a more advanced level  they can be reasonably difficult to develop end debug but there are a large number of well proven reliable macros available that increase the throughput of reliable code.

For normal integer evaluation.

The range of macros to automate tasks in MASM is almost unlimited yet while it may look like high level code it is in fact inlined hand written assembler code to improve your code throughput and maintainance without compromising performance.

While the pseudo high level capacity in MASM is very useful and has a proven track record over time, its real power is in its ability to write the complete Intel instruction set from conventional integer instruction to floating point instructions and register, MMX and the series of late XMM (SSE) instructions with near complete freedom of architecture.

With manually written mnemonic code you have as much or as little structure as you require and this is one of its great advantages over even the best compilers, the near total freedom to write anything you need without artificially imposed limitations.

Below is a simple algorithm using SSE instructions to XOR a random pad against data to be encrypted. It is written using a normal stack frame as the stack overhead is not a factor in its timing and the source and pad must be 16 byte aligned for the SSE instructions used. It is unrolled by a factor of 4 and uses non-temporal writes to avoid cache pollution with incoming data.

Built as an object module it can be used in either a MASM program or linked directly into a Microsoft VC application, one of the major targets of MASM as it is supplied with Visual C.

Algorithms written in the normal integer instructions are commonplace and still do the lion share of work in most applications. Below is an algorithm to perform the mundane task of replacing ASCII zeros with spaces in large text files that occasionally have embedded zeros that prevent them from being read in a normal editor.

It is written without a stack frame and is unrolled by a factor of 4 to improve its throughput by reducing loop code overhead.

With MASM the sky is the limit and while there are many tasks that are not worth making the effort to write, where you do need to target the speed of a particular process in an application, MASM is the tool that can produce any algorithm you know enough about to write.

MASM is not for the faint of heart, it is a technically demanding tool that requires a good working knowledge of both the operating system and the available mnemonics that the processor supports but it puts the final control of an algorithm in the hands of the programmer who chooses to master a tool of this type.