Brain Droppings

A recap of 2015

Tue, 12 Jan 2016 00:00:00 +0000

A recap of things that I’ve discovered, learned, read, met, etc. in 2015 in no particular order old or new.

Reading and videos on software

40 NPM Modules We Can’t Live Without - an excellent collection of very hepful node package modules.
Functional Composition - a gentle introduction in composing and create higher order functions.
Functors, Applicatives, And Monads In Pictures - more functional programming goodness in pictures.
10 Technical Papers Every Programmer Should Read(At Least Twice) - a breadth of information that is useful from a computer science perspective.
TPL and async/await Best Practices for the Busy Developer - A comprehensive guide to understanding and utilizing the C# task parallel library.
What Is Functional Programming - Understanding what makes languages functional.
Which Programming Languages Are Functional - Understanding what languages are actually functional.
Using Lists with Entity Framework - Necessary if your working with EF complex types.

[Build 2015

Channel 9 Service Fabric Session](https://channel9.msdn.com/Events/Build/2015?sort=sequential&direction=desc&term=Service+Fabric#theSessions) - Researching the new service fabric distributed systems for work.

Volatility-Based Decomposition - a coworker introduced me to Juval Lowy’s software architecture design, worth the watch.

Programming languages I’ve hacked on last year

JavaScript, FSharp, Go

CSharp, JavaScript, FSharp, TypeScript

Programming languages that I hope to explore this year

Idris - Just picked up Type Driven Development in Idris!
Go - I explored GO a while back, but now a fellow software engineer acquaintance wishes to do some projects in go.
F# - Honestly I’ve been playing with F# for the past eight months, and I hope to do more open source contributions this year.

Papers discovered (and read)

In Search of an Understandable Consensus Algorithm - Actually read this a while back, but is a worthy of mention here for those that wish to understand the internals of distributed systems without losing their mind.
Managing Technical Debt with the SQALE Method - excellent read on how to analyze and quantify your teams technical debt.

Community efforts

CharlestonJS - I’ve recently taken over as head of the CharlestonJS meetup group, this couldn’t be possible without the help of The Iron Yard - Charleston
CODETalks 2015 - My presentation of Juval Lowry’s volatility based decomposition. This was a great experience and I hope to be back again in the future.
Charleston Teck Slack - I joined what’s possibly the best thing to happen to the Charleston tech scene.

Music discovered

Mulatu Astaqe - Ethiopian music is amazing! Check it out!

Games discovered

The Long Dark - I’ve been playing survival games for a bit, and this one honestly captures the extreme pressures of surviving in the wilderness.

Etc

Andres Bees - I’ve become an amatuer beekeeping and decided to start a blog to track my progress and learn from my mistakes.

Plans for 2016

Contribute to the visual Fsharp power tools.
Write some type providers in Fsharp.
Write some Go.
Discover some new music.
Play guitar more.
Play my berimbau more.

Comments

What I Learned Reading the FSharp Source Part One

Wed, 30 Sep 2015 00:00:00 +0000

As part of my learning experience into the F# language, I’ve taken the time to begin reading through parts of the source code that catches my eye to gain a stronger foothold and understanding of the language that I would usually skim over when reading the MSDN docs. The nice thing about reading the source code is that they provide tests to describe the functionality. So most of my time will be spent exploring the tests, some of the source code, and MSDN documentation. Lets begin!

Arrays:

Arrays are not immutable according to the tests where the Array.set method is used to modify an index within the array. Once I saw that I immediately went to the MSDN docs and discovered that “Arrays are fixed-size, zero-based, mutable collections of consecutive data elements that are all of the same type.” I haven’t had a use case for arrays in my work so far, but I can forsee it being useful for collections that will never change size.

Concat

Arrays can be built from sequence expressions, which I find quite nice to look at.

We can also combine expressions to build multidimensional arrays, and that Array.concat will concatenate (flatten) an array of arrays the documentation states and provides and example that it only concatenates a sequence of arrays. This confused me at first that the documentation would state a sequence of arrays, but I was reminded that array implements IEnumerable<T>. Looking at the signature of Array.concat:

We see that it indeed does take a sequence of arrays then Seq.ToArray is called before the concat operation happens. If we are given an array of arrays then we go straight to the concatArrays method thanks to the match expression. Where we see the operator :? that matches the value to the type expression ('T[][])

Which then calls an internal methods concatArrays, concatAddLengths, and concatBlit to return a result.

There is a whole lot of goodness going on in these three functions so let’s dive in! The first thing that catches my attention is this line:

Where we call zeroCreateUnchecked hiding at:

That calls a common Intermediate language instruction (cil) # newarr that creates a new array of type ‘T of the concatenated array length of all zeros. Then we call concatBlit with the array of arrays, two counters, and the combined length of the final array. Within that method we have a check for the i counter is greater than the number of arrays in the array, assign h to the “i”th array assign len to the length of h. Then we call the class method Array.Copy.

Array.Copy then uses the class method Array.Clone to create a shallow copy of the one-dimensional array that is down casted using the operator :?> to a type of array ‘T[], where originally they were using zeroCreate and a for loop to push the values. Finally the new array tgt is built recursively until the i counter equals the number of arrays in the array. Whew! that’s a lot for just Array.concat!

Sub

Next on to Array.sub where we see some tests for it here:

Then the module definition here:

Where we first do some validation of the array to make sure it is not null and within the array bounds. Next we call subUnchecked located at with the startIndex, count, and the array:

Which it then calls on zeroCreateUnchecked to initialize an empty array, then we check if the size of the desired subarray is less than 64 indexes, and use a for loop if it is or the class method Array.Copy if it is greater. The reasoning behind this is probably due to the efficiency that a for loop has over arrays less than 64 indexes.

Folding and Optimized Closures

Now taking a look at module definitions for folding:

What really catches my eye is “OptimizedClosures.FSharpFunc”. So looking at the documentation here I learned that it is used to invoke the implementation of a function. It reminds me of a C# Func<> delegate, but I imagine there is more going on here. So we find the optimized closures and fsharp func located here Going back to fold module definition

We see the FSharpFunc is invoked to update the mutable state.

Well that’s it for part one of my exploration of the fsharp source code. Please let me know if I missed anything interesting or explanations within my current search.

Comments

Automapper and Entity Framework Proxies

Tue, 25 Aug 2015 00:00:00 +0000

I’ve recently learned about Automapper for mapping objects to other objects and I couldn’t be happier with the results from its use in my day to day projects. However I did come across a situation where I needed to map POCOs to entity objects. What I was trying to do is map the properties of the POCO to an entity that needed to be modified and saved during an update operation within my Web API project. So using the familiar:

However I discovered that Automapper was removing my retrieved entity object from the object graph that entity framework provides us in order to track changes of the object state. This of course was not acceptable and I didn’t want to have us go through and map the properties of POCO to entity by hand.

Now I could go and call the static Mapper class and define the types of the objects every time I need to map from POCO to entity making use of typeof:

But this isn’t a great way of enabling these mappings, plus its a lot of typing, so I created a helper method that wraps this logic and makes use of generics types instead of using typeof as parameters of the method:

Comments

Nginx and Angular url routing

Mon, 18 Aug 2014 00:00:00 +0000

Lately I’ve had the opportunity to work with Angular on a regular basis. At first it has been a challenge due to a large learning curve with the framework. But after a couple projects things have been moving smoothly. Anyway this post is a blurb on how to properly route request from Nginx to your Angular application.

Lots of resources recommend the follow Nginx configuration for your application.

Note that this is working with an Angular app that is running in html5mode.

So in our Nginx conf we have our root location try_files directive that checks for the existence of files in order, and then returns the first file that is found.

Now this gets us 50% of the way there. What happens when you have nested routes? e.g. foobar.com/fizz/buzz or query strings? e.g. foobar.com/fizz/buzz?ping=pong.

Well Nginx gets you part of the way there with query strings but not nested routes. After some hours of reading Nginx documentation and searching for answers, I came across this solution.

In you Angular application entry point file, usually index.html. Inside the head tag section place this tag, <base href="/">

This will allow Angular to handle all route request properly.

Comments

Docker, CentOS, and Aerospike DB

Wed, 02 Jul 2014 00:00:00 +0000

My recent endeavors with Docker have been quite rewarding. From creating a MongoDB cluster, to a Nginx load balanced reverse proxy container that routes an Angularjs container with a Nodejs API container backing that up. Theres definitely no looking back to provisioning VMs alone anymore.

But recently a new database has piqued my interests Aerospike. So with this new NoSQL DB I wanted to run it within a CentOS container. However there are some current problems that you may run into until the CentOS 6.6 base image is released on the public docker registry.

Primarily the issues that arise are the package dependencies that Aerospike and the Aerospike documentation call for. Here is the example from my current Dockerfile

Starting at the Install necessary software and dependencies comment I install wget, tar, logrotate, sudo, and the final odd command system-config-services. This is where you may run into trouble since the documentation requires you to start your Aerospike with the command sudo service aerospike start and you get centos complaining that sudo or service doesn’t exist.

But those final two commands will help resolve this issue. If you notice that the system-config-services command is prepended with --enablerepo centosplus this allows yum to get packages from the CentOSPlus repository.

Now CentOS recommends that when you require dependencies from that repository to only enable it when you can to pick the exact package that you want to use, vs. enabling it in your /etc/yum.repos.d/ since it is not part of the CentOS upstream distribution. So consider this fix to be experimental until the updated base image is released.

I plan on following up with a demostration of an Aerospike cluster using containers so stay tuned.

Comments

Large query string values and Azure

Thu, 26 Jun 2014 00:00:00 +0000

By default Microsoft IIS accepts a maximum query string length of 2048 characters. If there is a query string received by the IIS with more than 2048 characters, it will throw a 404.15 - Query String too long error.

If your running a service on Azure and are running into issues sending very large values over http via a get request. Then you will have to set the maxQueryString property value to compensate for your request.

Unfortunately many answers to this problem fail to address when working on an azure instance. In that context you will need to upload a Web.config file to the wwwroot folder of your instance. Under the system.webServer, security section, add the requestFiltering section. Under the requestFiltering section, add the requestLimits tag with your desired maxQueryString value. Now your web service or web site will be able to accept a maximum query string length you desire. In the example below I have it set to accept a maxQueryString value of “10000” characters. Even if you set a big value for maximum query string, there is a limit for each browser which is handling the url and the query string.

The best practice is to limit the maxQueryString size as much as possible, to avoid any injection attacks. You can give a value based on your requirements, but keep in mind that alllowing long query strings is a potential security risk and bad design.

Comments

Code Talk Python vs. PHP vs. Ruby

Thu, 08 May 2014 00:00:00 +0000

I was invited to give PHP a fighting chance at the Charleston Digital Corridor CODEtalk forum. Check out the video here.

Brain Droppings

A recap of 2015

Reading and videos on software

Programming languages I’ve hacked on last year

Programming languages used for work-related projects last year

Programming languages that I hope to explore this year

Papers discovered (and read)

Community efforts

Music discovered

Games discovered

Etc

Plans for 2016

Comments

What I Learned Reading the FSharp Source Part One

Arrays:

Concat

Sub

Folding and Optimized Closures

Comments

Automapper and Entity Framework Proxies

Comments

Nginx and Angular url routing

Comments

Docker, CentOS, and Aerospike DB

Comments

Large query string values and Azure

Comments

Code Talk Python vs. PHP vs. Ruby

Comments