in Code

Okay! In this series we will be going over many subjects in both physics and computational techniques, including the Lagrangian formulation of classical mechanics, basic principles of quantum mechanics, the Path Integral formulation of quantum mechanics, the Metropolis-Hastings Monte Carlo method, dealing with entropy and randomness in a pure language, and general principles in numerical computation! Fun stuff, right?

The end product will be a tool for deriving the ground state probability distribution of arbitrary quantum systems, which is somewhat of a big deal in any field that runs into quantum effects (which is basically every modern field). But the real goal will be to hopefully impart some insight that can be applied to broarder and more abstract applications. I am confident that these techniques can be applied to many problems in computation to great results.

I’m going to assume little to no knowledge in Physics and a somewhat intermediate working knowledge of programming. We’re going to be working in both my favorite imperative language and my favorite functional language.

In this first post I’m just going to go over the basics of the physics before we dive into the simulation. Here we go!

Read more … Comments

One of the crazy ideals of functional programming is the idea that your program is simply a list of definitions of mathematical functions. And like real math functions, FP functions are pure. That means that (1) they cannot affect any state, and (2) that they must return the same thing every time they are called with the same arguments.

When you first learn functional programming, this manifests as “your variables are immutable and you can’t do loops; use recursion instead.” And if you do that, everything is “fine”.

However, there is an apparent glaring problem with this adherence to purity: I/O. Input and output are inherently stateful.

Read more … Comments

What do you use to send off quick one-off notes and logs about a project you are working on? Found a nice link to a resource you’ll want to look up later…want to jot down a sudden realization?

Maybe you use some external note-taking software, like Evernote. But wouldn’t it be nice to have something that is completely in the command line? Do you really need to fire up an entire GUI just to write down one line, put down one link? And do you really need these notes to all be thrown in with your others?

You might be using a command line interface to a larger note-taking system like geeknote. But it’s kind of a hassle to open up an entire text editor every time you want to make a small one-liner. Doesn’t quite meld with the Unix philosophy. Maybe you are comfortable simply appending to a text file with >>…but what if you want to add things like timestamps?

Here’s introducing log.sh.

Read more … Comments

UPDATE: This post was written in 2013, where the options available to someone looking to host a Haskell site on Heroku were fairly limited. It’s (as of the time of writing this) 2015 now and things have changed. Check out the comments for two good alternatives to this that are working today!

Consider the rest of this article obsolete, or look here if none of the solutions given in the comments work :)

Read more … Comments

As we left it off in part 1, our elevator is still in trouble. You have an elevator for your humble hotel that consists of a plate being pushed up a shaft with a fountain of water where we can control the fountain strength, but you don’t really have any way to automate getting it to go to just the right height.

You’ve tried writing down the proper fountain strengths for every floor, but changes in weight of the hamsters and lots of other factors make this unreliable. You’ve tried mathematically analyzing and accounting for all of these other factors, but not only is it impractical, but it can’t possibly account for dynamic changes in the system.

Let’s take a look at a possible solution that might have some promise.

Read more … Comments

Over this summer my work has been in the field of control theory. I must admit that I at first found it a little odd that the idea of “controlling something” — say, the temperature of a room or the speed of a fan — could be an extremely deep/rich mathematical and engineering discipline.

This series should hopefully be an enlightening walk through this wonderful world that is control theory, and explore (without any complex mathematics) just how much genius goes into those simple things we all take for granted.

Welcome to the Hamster Hotel.

Read more … Comments

As someone who comes from a background in ruby and rake, I’m used to powerful task management systems with expressive dependency. Make is a favorite tool of mine when I’m working on projects with people who don’t use ruby, and when I’m working on ruby projects I never go far without starting a good Rakefile. The two tools provided a perfect DSL for setting up systems of tasks that had complicated file and task dependencies.

As I was starting to learn Haskell and building larger-scale Haskell projects, I began to look for alternatives in Haskell. Was there a Haskell counterpart to Ruby’s rake, Node’s jake? (Not to mention the tools of slightly different philosophy grunt and ant)

It turns out that by far the most established answer is a library known as Shake (maintained by the prolific Neil Mitchell of hoogle fame and much more). So far it’s served me pretty well. Its documentation is written from the perspective of chiefly using it as a build tool (more “make” than “rake”), so if you’re looking to use it as a task management system, you might have to do some digging. Hopefully this post can help you get started.

I also go over the core concepts of a task management system, so I assume no knowledge of make; this post therefore should also be a good introduction to starting with any sort of task management system.

Read more … Comments

Throughout my time programming and developing, I’ve noticed that there are few legitimately useful sources of practical and beneficial knowledge on the subject on the internet. There are good books. There is Stack Overflow. And there are the blogs.

I’ve probably learned more useful information from blogs than I have from nearly any other source — from small things like how to fix that compile error on ffmpeg or teaching me my first steps in learning tools I now use every day like git. From blogs I’ve learned not just small things that help me here and there, but also the building blocks that I have to thank for allowing me to learn so much of what I know now.

In addition to these, blogs are the theatre of many gifted essayists, who are always enthusiastic to share their insight from the deeper aspects of what programming actually means, and their roles in the construction of the world we live in today.

Having worked on my fair share of projects, I’ve accumulated some meager, humble practical knowledge from the field over these short years. So this is my opportunity to finally give back. My hope is first to fill in all of those small holes in knowledge that happen to slip through and can sometimes only be found with the perfect google search. Second to share a bit of my discoveries along my journeys in development and any relevant insights from my studies that may be useful to others. Third, to share any mature open source projects I’m working on that may be of use to the world. And forth, to maybe shine some light on greater themes that I have noticed when looking back on things.

It’s also been said that blogs are a good way for someone to help themselves organize their thoughts and kind of put them all together. Maybe if I log my progress on projects as I go along, I can look back and refer to them later. And maybe — just maybe — they can be useful to other humans.

So anyways, this is it. Welcome to in Code!

Read more … Comments