Inevitably, I have moved away from blogging as often as I would have liked to, and this time it has been for a number of pretty decent excuses; since the last time I have been active:
- I got married
- I took over a team at work and became extremely busy
- I have dove head first into my goals for the year
So instead of guilting myself over my lack of blogging activity, I am thinking of this situation in the same way the oatmeal describes creativity, that it is like breathing. So instead of getting all worked up or making up excuses for not keeping the blogged ball in the juggling act, I am choosing to view it as I do the juggling act to make my blogging better. So time for a breath out.
The wedding and the whole destination experience deserves its own post and it will get that soon enough.
One of the big things I have been taking on is learning Rust. I followed Tensor Programming’s guide on rust, and took The Rust Programming Language on Udemy to get the basics down. Then I started working on some small side projects and working through problems on CodeFights in rust to get a hang of thinking about memory management and types. I will share my deeper thoughts on Rust in an upcoming post.
I also took on further mastering Elm. I have been porting one of my sideprojects from an Angular(2-5) to Elm and have gone from struggling with The Elm Architecture patterns to it making entire sense and loving it. The ability to rely on the compiler to make sure everything will do what I intend it to do and to be able to time travel debug problems that have come up.
Returning to playing Kittens Game (warning can be extremely addicting), after a few years of not touching it. I then started designing a Event Sourcing version of the game. Event Sourcing is a data design pattern where instead of implementing a CRUD style database, instead data is stored as an immutable stream of events. For example, if you wanted to model a bank account, instead of transactions mutating balance in place, every transaction would be put into an event stream, and a stream processor would iterate over the stream, and aggregate the balance from all of the transactions. The resulting benefits including getting an entire audit record that is the source of truth for free, being able to time travel and see the balance at any point in time, and depending on how backups and streaming goes, the ability to easily rebuild the entire state of your application at any point in time from scratch. To reduce the processing power required to evaluate the long streams, implementations often cache the state result, and modify it as new events come in. I have been designing a system to re-implement kittens game using an event sourcing stream, which would prevent cheating (modifying the object in memory wont work since the data is immutably derived from the stream), and it allows for tweaking the game configuration without having to restart the game to test them out. So not only does this allow time travel debugging, during development, it allows for alternate reality debugging. Next steps for this could be enabling multi-player by moving this immutable stream of events to an immutable distributed ledger; also known as a blockchain.
Partially in Conjunction with learning Rust, I have started playing with Web Assembly. The promise of super fast calculations written in a type safe language and being compiled to web executable bytecode is super exciting to me. Not only is there a ton of complex processing at work that can be done by dumping work off to a WASM module, but there are a ton of other things that can be done as far as speeding things up and adding safety.
Since the last post, I have fallen in love and become completely disenchanted by APIStar, a fast python API framework from the makers of DRF. It is python3 only, and uses type hinting for dependency injection, allowing the API code to be very declarative while being super fast. However since I started using it, there has been 3 backwards breaking releases that has left a lot of my codebase stranded. Ill cover more about it and its direction in another post.
I have started playing with the NEAT algorithm that I became enchanted with after watching Mar.io. The idea of letting survival of the fittest to evolve solutions from nothing as opposed to using a ton of training data is super cool to me and I have been looking at ways to incorporate it into some projects.
Im still continuing to be pretty heavy in my exploration of different technologies; I plan on exploring Haskell and Elixir in the near future. However as I feel myself approaching the peak of my inhaling, I will begin to start blogging and collecting my thoughts. I have another year of LaSalle Tech Academy coming up, so switching modes back to teaching will most likely prompt more creative exhaling.