Exercises in Programming Style–Reflective

NOTE : read the rest of the series, or check out the source code.

If you enjoy read­ing these exer­cises then please buy Crista’s book to sup­port her work.

exercises-prog-styles-cover

Fol­low­ing on from the last post, we will look at the Reflective style today.

 

Style 17 – Reflective

We’re now officially at the halfway mark in this series, I hope you’ve enjoyed the series thus far and today’s style is a funky one!

Constraints

  • The program has access to information about itself, i.e. introspection (see last post on how it differs from reflection)
  • The program can modify itself – adding more abstractions, variables, etc. at runtime

 

In her example, Crista used Python’s metaprogramming capabilities to:

  • dynamically inject additional functions based on the arguments passed into the script
  • eval these new functions and capture the return values into the running application

The metaprogramming capabilities of .Net languages have improved significantly since the availability of Roslyn and the F# compiler service, but it’s still nowhere near what one can easily do in Clojure, Ruby, Python and other dynamically typed languages.

 

First, we need to go and grab the F# Compiler Service package from Nuget.

Then, we need to reference it in our script and follow the tutorial on embedding the F# Interactive (FSI) in our application:

Style17_01

Once we have an instance of FsiEvaluationSession, we’re mostly interested in its EvalExpression method. Before we move on, let’s add another helper function to deal with its result:

Style17_02

Now we can start writing our code as strings, yay! 

Couple of things I noticed whilst experimenting with the following:

  • you can’t open namespaces in the source code
  • you can’t read files in the source code

which is why I used fully qualified names for System.IO.File.ReadAllText, and why it’s only used in composition and not directly invoked in the source code.

Instead, the code that’s captured in the string below will return an extractWords function with the signature

string -> string -> string[]

When we later evaluate it we’ll need to cast the result to that type and invoke the function with the paths to the stop words file and the input file for Pride and Prejudice.

Style17_03

We’ll apply the same approach and create a piece of code that returns a function with the signature :

string[] -> (string * int)[]

Style17_04

and another function that’ll take the word frequencies generated by the code above, sort them and print the top 25 results on screen:

Style17_05

Finally, all the pieces are in place.

Now, we can string everything together (pun intended) by:

  1. evaluating the code snippets above
  2. capture the results and cast them to corresponding types
  3. invoke them with the paths to the stop words file and the input file

Style17_06

and voila!

 

You can find the source code for this exer­cise here.

Liked this article? Support me on Patreon and get direct help from me via a private Slack channel or 1-2-1 mentoring.
Subscribe to my newsletter


Hi, I’m Yan. I’m an AWS Serverless Hero and the author of Production-Ready Serverless.

I specialise in rapidly transitioning teams to serverless and building production-ready services on AWS.

Are you struggling with serverless or need guidance on best practices? Do you want someone to review your architecture and help you avoid costly mistakes down the line? Whatever the case, I’m here to help.

Hire me.


Check out my new course, Complete Guide to AWS Step Functions. In this course, we’ll cover everything you need to know to use AWS Step Functions service effectively. Including basic concepts, HTTP and event triggers, activities, callbacks, nested workflows, design patterns and best practices.

Get Your Copy