The world is swarming in lists, to-dos, shopping, sprint backlogs. Linear in nature they help us mere mortals keep track of things and their relationships to each other. Having a re-visit to this fundamental data structure with the help of Rust.
thoughts on simplicity
coways game of life in wasm
first steps with wasm
A look at basic building blocks of rust
A look at basic building blocks of rust
A look at basic building blocks of rust
A look at basic building blocks of rust
A look at basic building blocks of 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.
Some thoughts and ideas as I begin to write again
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 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.
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.
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 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 is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback).
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.
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.
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.
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.
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.
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.
A facade is an object that provides a simplified interface to a larger body of code, such as a class library.
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.
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 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.
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 is an object creation software design pattern with the intentions of finding a solution to the telescoping constructor** anti-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".
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
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.
Recurions is one of those topics in programming that I have had an interest in. Partly because infinate recursion is well... so weird.
The goal of this post is to examine simulations where the objects make decisions.
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....
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.
How do changes in state translate to changes in the DOM?
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"
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.
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.
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.
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.
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.
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.
Last time I looked at how normal distribution can make make random numbers consistently closer to the mean.
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.
Wouldn't it be great to generate sets of numbers that seem more naturally distributed.
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 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.
CSS can be painful to write and even worse to maintain...
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
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.
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.
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.
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.
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.
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 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.
I have been teaching myself Node.js over the last few weeks and it has really tested my JavaScript skills.
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.