‡ simplicity
thoughts on simplicity
::
∅
∴
‡ a wasm way of life
coways game of life in wasm
‡ wasm first steps
first steps with wasm
‡ ownership in rust
A look at basic building blocks of rust
‡ control flow in rust
A look at basic building blocks of rust
‡ functions in rust
A look at basic building blocks of rust
‡ data types in rust
A look at basic building blocks of rust
‡ variables and mutability in rust
A look at basic building blocks of rust
‡ why rust
There is something drawing me down into the system, closer to the metal. As someone who has spent the majority of their time up in the clouds of abstraction (JavaScript) learning a language closer to the machine has its appeal.
‡ thinking out loud
Some thoughts and ideas as I begin to write again
‡ the template pattern
In software engineering, the template method pattern is a behavioral design pattern that defines the program skeleton of an algorithm in an operation, deferring some steps to subclasses. It lets one redefine certain steps of an algorithm without changing the algorithm's structure.
‡ the state pattern
The state pattern is a behavioral software design pattern that implements a state machine in an object-oriented way. With the state pattern, a state machine is implemented by implementing each individual state as a derived class of the state pattern interface, and implementing state transitions by invoking methods defined by the pattern's superclass. The state pattern can be interpreted as a strategy pattern which is able to switch the current strategy through invocations of methods defined in the pattern's interface.
‡ the strategy pattern
In computer programming, the strategy pattern (also known as the policy pattern) is a behavioural software design pattern that enables an algorithm's behavior to be selected at runtime.
‡ the visitor pattern
In object-oriented programming and software engineering, the visitor design pattern is a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying those structures. It is one way to follow the open/closed principle.
‡ the observer pattern
The observer pattern is a software design pattern in which an object, called the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes, usually by calling one of their methods.
‡ the memento pattern
The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback).
‡ the mediator pattern
In software engineering, the mediator pattern defines an object that encapsulates how a set of objects interact. This pattern is considered to be a behavioral pattern due to the way it can alter the program's running behavior.
‡ the iterator pattern
In object-oriented programming, the iterator pattern is a design pattern in which an iterator is used to traverse a container and access the container's elements. The iterator pattern decouples algorithms from containers; in some cases, algorithms are necessarily container-specific and thus cannot be decoupled.
‡ the command pattern
In object-oriented programming, the command pattern is a behavioral design pattern in which an object is used to encapsulate all information needed to perform an action or trigger an event at a later time. This information includes the method name, the object that owns the method and values for the method parameters.
‡ the chain of responsibility
In object-oriented design, the chain-of-responsibility pattern is a design pattern consisting of a source of command objects and a series of processing objects. Each processing object contains logic that defines the types of command objects that it can handle; the rest are passed to the next processing object in the chain.
‡ the proxy pattern
A proxy, in its most general form, is a class functioning as an interface to something else. A proxy is a wrapper or agent object that is being called by the client to access the real serving object behind the scenes. Use of the proxy can simply be forwarding to the real object, or can provide additional logic. In the proxy extra functionality can be provided, for example caching when operations on the real object are resource intensive, or checking preconditions before operations on the real object are invoked.
‡ the flyweight pattern
In computer programming, flyweight is a software design pattern. A flyweight is an object that minimizes memory use by sharing as much data as possible with other similar objects; it is a way to use objects in large numbers when a simple repeated representation would use an unacceptable amount of memory.
‡ the facade pattern
A facade is an object that provides a simplified interface to a larger body of code, such as a class library.
‡ the decorator pattern
In object-oriented programming, the decorator pattern is a design pattern that allows behavior to be added to an individual object, either statically or dynamically, without affecting the behavior of other objects from the same class. The decorator pattern is often useful for adhering to the Single Responsibility Principle, as it allows functionality to be divided between classes with unique areas of concern.
‡ the composite pattern
In software engineering, the composite pattern is a partitioning design pattern. The composite pattern describes that a group of objects is to be treated in the same way as a single instance of an object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies. Implementing the composite pattern lets clients treat individual objects and compositions uniformly
‡ the prototype pattern
The prototype pattern is a creational design pattern in software development. It is used when the type of objects to create is determined by a prototypical instance, which is cloned to produce new objects.
‡ the singleton pattern
In software engineering, the singleton pattern is a software design pattern that restricts the instantiation of a class to one object. This is useful when exactly one object is needed to coordinate actions across the system.
‡ the builder pattern
The builder pattern is an object creation software design pattern with the intentions of finding a solution to the telescoping constructor** anti-pattern.
‡ the factory pattern
In object-oriented programming (OOP), a factory is an object for creating other objects – formally a factory is a function or method that returns objects of a varying prototype or class from some method call, which is assumed to be "new".
‡ starting ~ 2019
‡ sierpinski triangle
The Sierpinski Triangle is rather beautiful. I thought might be interesting to try and create it in code. Luckily I was able to find many others who had attempted the same thing. I did a little reading on what was involved and the steps are pretty straight forward
‡ gravitational attraction
If you want to see the pull of gravity, drop whatever you're holding right now. If you had listened, you may have seen your phone drop to the ground and bounce.
‡ recursion
Recurions is one of those topics in programming that I have had an interest in. Partly because infinate recursion is well... so weird.
‡ steering behaviour
The goal of this post is to examine simulations where the objects make decisions.
‡ piglatin and python
Back when I was a kid pig latin made no sense. I wanted to make a basic pig latin translator so if I ever come across it again I can at least hold a conversation....
‡ maze generation
First I have to think about how I am going to approach the maze.I'm using an HTML5 canvas which I will divide into a grid with each cell being it's own object. The program will figure out which walls of the cells to remove to create a maze.
‡ reactivity in javascript
How do changes in state translate to changes in the DOM?
‡ the bridge pattern
The bridge pattern is a design pattern used in software engineering that is meant to "decouple an abstraction from its implementation so that the two can vary independently"
‡ the humanness of programs
0110100001100101011011000110110001101111,Even something as simple as hello can seem strange and alien in machine language. Yet our world today in 2018 is shaped by 1’s and 0’s. These 1’s and 0’s represent state at the hardware level.
‡ how flappy bird was made
In 2013 a game was released that in the following year would take the world by storm. A young Vietnamese programmer named Dong Nguyen released a game that he would later remove from the App store from guilt of overuse and the addictive nature of the game. That game was Flappy Bird.
‡ the adapter pattern
In software engineering, the adapter pattern is a software design pattern that allows the interface of an existing class to be used as another interface. It is often used to make existing classes work with others without modifying their source code.
‡ force
A vector that causes an object with mass to accelerate. All objects with mass experience force. Some common forces,gravity, tension, spring, buoyancy, air resistance.
‡ acceleration
This year has really got off to a flying start. I'm super busy at work and school and I have been squeezing in non work related learning when I can. I have had to do more database work at my day job so I have been wrapping my head around that which has stunted my progress with the Nature of Code.
‡ vectors
‡ make some ( perlin ) noise
Perlin Noise allows us to make smooth randomness, It was originally developed to create textures in 3d graphics. Let's say we wanted to make a vase seem like it was made of marble. Rather than hand create we can use an algorythm to generate a texture.
‡ custom distribution : controlling the random
Last time I looked at how normal distribution can make make random numbers consistently closer to the mean.
‡ more vectors
As expected my schedule is only getting busier, however I have been squeezing in some learning on my lunch breaks. I learnt a little more about vectors and vector math this week so I'm sharing my notes.
‡ normal distribution, taming the random
Wouldn't it be great to generate sets of numbers that seem more naturally distributed.
‡ make a decision
As a web application developer I make a lot of decisions each day. The art of programming is making decisions ahead of time and writing the code to deal with the potential decisions the program should know how to make depending on the interactions of the user or other programs.
‡ probability and movement
Probability is the measure of the likelihood that an event will occur. It is a way to evaluate a given set of scenarios and decide how often will event x happen.
‡ starting ~ 2018
‡ css sanity with sass: setup.
CSS can be painful to write and even worse to maintain...
‡ sass ~ an introduction
In this post I am going to be building off a previous post. I went over how to install and setup Sass using Ruby aswell as the basic project structure, since that post I have came across away to use Sass with Nod
‡ the nature of code ~ first thoughts
‡ programming ~ in the works part two
‡ programming ~ in the works part one
‡ javascript beyond the basics ~ function composition
In the Beyond the Basics series I'll be exploring more intermediate/advanced topics in JavaScript in an attempt to understand these topics more on a personal level.
‡ javascript es6 ~ the way of the arrow function
Doing what is comfortable at the moment is not the best approach to learning how to code, for me anyway. Pushing yourself outside of your comfort zone is one of the most important parts of learning and getting good at a new skill. It's for that reason I have been making a conscious effort to embrace ES6.
‡ javascript 101 ~ closure
In this post I'm going to be taking a look at the idea of closure and how it can be used in JavaScript. Closure can seem almost mystical at first glance and can certainly be a mind bender.
‡ javascript 101 ~ this
If you have spent some time reading or writing JavaScript, you will have no doubt came across the `this` keyword. In other object orientated languages, the `this` keyword refers to the current instance of the class. In JavaScript the value of this depends on the context of the function and where it is called.Not knowing this or rather `this` can be confusing.
‡ javascript 101 ~ funky functions part 2
In the last funky functions I looked at the silently passed argument, ___argument___. I had full intention to talk about the other implicit argument ___this___ in part 2 but I found myself going down a different path.
‡ javascript 101 ~ better event handling
In a previous post I took at look event handling in JavaScript. The title of this post is a clue you can expect more of the same in this one.This time, my goal is to show that there is merit to spending some time refactoring and tidying up code once your idea has been stubbed out and is working, and hopefully in the following example I can make my case.
‡ javascript 101 ~ funky functions part 1
JavaScript has its quirks and that's one of the many things I like about it, but it does have some potential gotchas that are worth noting. In the 'Funky functions' series I'll be looking at some of these quirks as well as taking a deeper dive into functions in JavaScript.
‡ node js ~ sequelize and sqlite
I have been teaching myself Node.js over the last few weeks and it has really tested my JavaScript skills.
‡ javascript 101 ~ event handling
As I've found myself getting deeper into the world of JavaScript it's hard not to take notice of the vast amount of frameworks available to the would be developer. It's actually a little overwhelming at first. Still being relatively fresh to the world programming and web development in JavaScript, trying to pick a lane is tough.
‡ breaking ground