The Daily Hackademic

Lao Zi once said that a journey of a thousand miles begins with a single step. This blog will document one underdog's unconventional educational journey, as he goes about learning something new, every day. -- 千里之行，始於足下 --

[hackedu-blog1]

Semaphores

Semaphores are a primitive synchronization data structure used to ensure that only one given thread can change values that are used by other programs (this is called a “critical section”) at any given time. This ensures that all threads are synchronized with one another with respect to the value(s) and state of the given variables they use and is called providing “mutual exclusion” to a critical section. I’ve written another post about some other basic synchronization primitives here, if you’re interested.

Side note, a thread is a purely conceptual thing that represents the “control state of an executing program”. Think of it a part of a program that does one given task.  

Semaphores consist of one integer value and private methods that atomically increment or decrement the value, conventionally referred to as P() and V().

P() checks the integer value and if it is greater than zero, decrements it.

V() increments the integer value.

Now, there are two types of semaphores known as a binary semaphore and a counting semaphore. 

Binary semaphores’ integer value is restricted to be either 0 or 1, hence why its binary. Binary semaphores are the type of semaphore primarily used for mutual exclusion purposes. For binary semaphores, consider the integer value to be a boolean flag- if it has a value of 0, it means that no thread is modifying the critical section or “inside the critical section.” If it has a value of 1 then it means another thread is currently modifying the critical section. 

By extension of this, for binary semaphores, the function V() is then used to alert the rest of the system that a given thread is accessing a critical section, and P() is used to tell the rest of the system that a given thread is finished accessing a critical section. 

With “counting” semaphores, its integer value is used, as its name suggests, as a count that can take any non-negative integer value. They are typically used for things other than mutual exclusion.

[hackedu-blog1]

Compilers vs Interpreters

Modern computer programs (code) are typically written in high level languages (which read relatively similarly to normal english) and thus must be transformed into machine-byte code (the language that computers can actually understand) in order to be run by a computer. There are two main ways of doing this- either by compilation or interpretation.

A compiler works by taking code written by a programmer and transforming it into machine byte code. In the process, the compiler will “read” all of the code across various files, “understand” everything that needs to go on and then based on this understanding, will transform the structure of the code and optimize it. After these tweaks and optimizations, it will eventually output equivalent machine code. This is the code that actually runs on the computer.

An interpreter however, maps specific operations in a given language’s code syntax to specific machine-byte code representations, generally speaking. This means that the interpreter can run your code much faster than a compiler, as it does not have to bother with “reading through” and “understanding” all of your code before it can be compiled into something that runs. It just does a relatively simple “translation”.

So does this mean that interpreting is definitively the way to go? Not necessarily. Each has its advantages and deciding which to use - usually in the form of choosing which language to use, as specific languages are only compiled, others are only interpreted - depends on what tradeoffs you want to / can make. Interpreting gets your code to run faster, but the tradeoff is runtime performance, since the interpreter does next to no optimizing of your code compared to what a compiler does. With compilers and compiled languages, yes it means you have to now wait for your code to fully compile (which with any serious project can take a notable amount of time), but the machine code produced is highly optimized and will be very performant. 

[hackedu-blog1]

Common Regex Commands

[ ] --> match against the set(s) specified within the square brackets 

+ --> the token before the plus must happen at least once

* --> the token before the asterisk can happen zero to n-times

\s --> denotes some kind of whitespace (matches against a `tab`, `space` or `newline` character)

() --> capturing group that takes a sequence of regex commands and makes them into one larger token

| --> equivalent to the boolean “or”

a-z --> the set of chars from lowercase a to lowercase z

A-Z --> the set of chars from uppercase A to uppercase Z

example:

[A-Z]+:( 0| 1)+\\s*;\\s*

this will match against a string that:

starts with at least one upper case letter(s), up to any number of them,

followed immediate by a colon character

followed by at least one ‘0′ or ‘1′ any number of times,

followed by any number of whitespace char(s) (at least zero),

followed by a semi-colon,

followed by any number of whitespace char(s) (at least zero)

[hackedu-blog1]

Ternary Conditional

A ternary conditional is a type of fundamental programming operator (operators are special symbols that perform specific operations on one, two, or three operands, and then return a result) that follows this general form:

condition ? value_if_true : value_if_false

The condition is a boolean condition, meaning it will return either ‘true’ or ‘false’. Depending on this boolean’s result, one of the two values on the right side of the ? will be “chosen”. If the boolean’s result was ‘true’, the value on the left side of the : will be “chosen”, otherwise if the result was ‘false’, the value on the right side of the : will be “chosen”. The “chosen” value is then returned.

Using a ternary conditional operator is a common way of re-writing a simple if/else statement. For example:

if (a > b) {    result = x; } else {    result = y; }

can be re-written in a cleaner, more elegant, one-lined way:

result = a > b ? x : y;

[hackedu-blog1]

Engineering Analysis, a Holistic Systems Approach

I have always held a large amount of disdain for the verbose engineering analysis methodology they teach us and force us to employ through writing 20-35 page (minimum) reports in engineering school. 

I have come to realize however - as I was about to use said methodology to write a satirically over-analyzed blog post 

writing a satirically over-analyzed blog post about a small project I completed - that while the format is terrible, the underlying concepts and methodology of thinking have their merits. Particularly that not all of the concepts are immediately obvious and are thus worth spending time learning. 

Below, I summarize the key points of consideration in a generalized, holistic engineering approach to problem solving:

Step 1) Define the problem:

If you already have an idea of what problem you would like to solve,

Condense the problem at hand such that it can be described in one sentence. Write it out for clarity. 

Else, if you are looking for a problem to solve, or would like to think about a more specific problem to solve:

Brainstorm a bunch (~10) opportunities, condense them such that they can be accurately described in one sentence.

To decide which is a better opportunity to tackle, for each, consider who the “stakeholders” (ex. customers, manufacturers, distributors, etc...the exact list will depend on the kind of problem) are, what the cutting edge solution/product/methodology is within the realm/space of each opportunity.

Select one opportunity/problem, explicitly write down a specific justification for choosing it. 

Define roles of all involved team members.

Step 2) Analyze the needs of the client / end user, and come up with product requirements.

By interviewing relevant stakeholders, intuition or research, come up with a list of needs and organize them in a hierarchy 

Come up with specific product requirements, organize them in a hierarchy (2-3 levels) relative to their importance to the end user.

Define what success looks like: what specific benchmarks must the solution meet in order for it to be a good solution? Look to the product requirements for inspiration when coming up with benchmarks.

Step 3) Come up with solution concepts to address the needs from step 2.

Consider the problem as process in which the average user will happen upon the problem. 

Decompose this process into its component steps and write it out as a step-by-step process, the more detailed the better. This will help you gain a very thorough understanding of the problem and how users experience it. 

Then, consider how currently existing solutions / products are addressing each step of the problem-process. 

Use this revised version of the problem-process to identify problem areas currently being neglected, or where your solution could address a given problem area better. 

With these in mind, brainstorm concepts (~5-10) for products / solutions that could address these.

Step 4) Choose the best concept(s).

Select the top 3 concepts based on how well they align with the problem-process decomposition and the benchmarks established in Step 2. 

For each of the top concepts, come up with a user story that describes how the solution / product would be used by the user in the step-by-step problem process described in step 3. 

Draw rough sketches for each concept to visualize them and begin considering what their component parts hypothetically would be, what material would be used, how they might be assembled.

Determine key performance metrics based off the success benchmarks defined in Step 2 that can be used to assess the performance of each concept.

Discuss each concept and get user feedback from users about which concept would suit their needs better. The key here is to get feedback to verify your understanding of the problem, the effectiveness of the solution and to recognize any implicit assumptions you may have made, all before investing time and energy into building a prototype. One useful way to do this is using the Wizard of Oz technique.

Step 5) Prototype and Test the chosen concept(s)

Based off your feedback, determine which concept is the best fit for the problem and create a prototype plan for how you will create it. You generally want to take the lowest-cost or -overhead approach you can. Assuming that creating, manufacturing or machining a fully functional prototype will require a lot of time, effort or resources, typically this involves modelling the prototype mathematically or with a simulator and testing it with experimental values to optimize its performance.

Step 6) Analyze the results relative to the needs, and decide on the best solution.

Use your benchmarks and feedback to determine which solution is the best and proceed either with further prototype testing, or continue on to beta testing or maybe even production- your call!

[hackedu-blog1]

Compilers, an Overview

Generally, a compiler can be defined as a program that takes code written in a high-level language (ie. python or C++ or Java; high-level languages are characterized by being relatively similar to plain english) and “translates” it into machine-code (0′s and 1′s) that a computer can understand.

To be slightly more specific, this “transformation” can be described by first splitting the high-level code into smaller chunks and then organizing them in a tree structure (we’ll call this the ‘intermediate representation’ or IR for short). Some transformations are then applied to the IR, some optimizations might be made, and then the IR is translated into machine code.

[hackedu-blog1]

Computer Architecture, an Operating Systems Perspective

[TO BE REVISED]

An operating system can be defined as software the supports the hardware in the operation of a computer system. The notion of having software to support the hardware is key, because the motivation for having an operating system in the first place arises from hardware limitations.

A computer is fundamentally comprised of three main hardware components:

Central Processing Unit (CPU)

Random Access Memory (RAM)

Arithmetic Logic Unit (ALU)

Once turned on, the CPU constantly repeats the following processes:

instructional fetch from memory

decoding the instructions

executing the decoded instructions

writing back the result(s) of the given instruction

The completion of all four of these steps is referred to as a single “clock cycle” and the CPU will perpetually run through clock cycles until it is shut off. Modern CPUs are able to run at several (arbitrarily, n) Gigahertz, meaning n-giga clock cycles per second. This is incredibly fast, especially relative to memory access time, which is around 80ns for the average personal computer.

Keep in mind during these 80ns, the cpu is still racing through clock cycles at n-Gigahertz. However, without anything in memory, the CPU cannot do anything- the clock cycles the CPU goes through are wasted during this time. Wouldn’t it be great if we could somehow optimize the process to lower the amount of these wasted clock cycles? Well, you’re starting to see the rationale behind having an operating system.

The most basic optimization is to say, ok, while a given program has down-time and is not using clock cycles, we could let another program use those clock cycles. By cascading program operations in this way, we can begin to minimize CPU “down time” where its clock cycles are not being put to good use. This is called “multi-programming”, or coordinating CPU usage between multiple programs to optimize productive CPU clock cycles. This is where the operating systems comes in. The OS is responsible for managing hardware resources such that that optimizations such as multi-programming are possible.

For example, in multi-programming, each program must be assigned a specific “section” of RAM by the operating system (otherwise, by default when a program is loaded into RAM it has access to all RAM. In fact after each program is loaded into RAM and the OS assigns it a specific section and amount of RAM, the program still believes it has access to all of the RAM, only in reality thanks to the OS, it has access to all of a portion of the total available RAM.). In particular, each program has a specific state that it expects the CPU to be in when it runs because each program assumes it is the only program running on a given machine when it is run. This “state” it expects can be described with respect to specific values for registers (small set of memory inside the CPU) or the program counter (a digitally encoded queue of instructions the CPU is to perform next; every clock cycle, tasks are enqueued to the program counter after they are decoded) on the CPU. When the computer system switches between which program is using clock cycles - this is known as context switching - the state of the CPU must be updated with respect to what that given program expects. This is done by the OS.

[hackedu-blog1]

Intro to Regex

Part of a project I’m working on requires parsing strings and interpreting them as commands if the strings contain certain key words. “Regex” stands for “regular expressions”, which refers to a sequence of characters (ie, an expression) that define a pattern of interest that a computer can then look for in a given block of text. A great example of this is our use case, where we are looking for specific key words in a specific order (this is our pattern of interest) in an email (this is our block of text).

Regex is kind of like a language of its own, in that you use individual keyboard characters - which each represent a different rule or statement - to define the overall pattern of interest.

For example, 

^hello\s(world|dude|lady)$

is a regular expression that defines a pattern of words we are looking for in the body of text. Specifically: 

the ^ at the beginning represents the start of the string, 

“hello” is an exact string match, 

\s refers to exactly one whitespace character,

(world|dude|lady) means an exact string match for either “world” OR “dude” OR “lady”

and finally $ refers to the end of the string.

So this will return a string if it starts with “hello”, followed by exactly one space character, followed by either the word “world”, “dude” or “lady”. 

This is just a brief example of regex characters; there are quite a few more that you can use to specify different patterns of interest to search for! But more on that as I learn more about regex myself!

[hackedu-blog1]

Today I Learned, Rapid Fire

If you are feeling tired, dizzy or slightly queasy, often the solution is just to drink water as these are symptoms of mild dehydration. If you're ever stuck outside without a computer but need to do research on the Internet and doing it on your phone just isn't cutting it, go hit up an Apple Store and use their MacBooks or even their iMacs or Mac Pros. Washing a beanie in the washing machine can potentially rip the embroidery off. Guess it was a bad quality-embroidered beanie. Packing for trips / moving sucks. A lot. Get an early start and do a little bit every day. Taking time off to escape from the vagaries of the real world every now and then is extremely therapeutic.

[hackedu-blog1]

Sparts 101

I recently started working on a personal project with a good friend of mine, using a python library called Sparts. Developed by the folks at Facebook, Sparts makes it dead simple to write new services (ie. software that continuously runs, doing whatever you’ve programmed it to).

Sparts is built on top of two foundational concepts: 

A “task” is, as its name suggests, a task that you would like to happen.

A “service” is a perpetually running program (otherwise known as a “daemon”, in computing-speak) that performs the tasks you write and specify.

You generally will have one service that runs many tasks; these tasks can run continuously, at regular intervals, or just once depending on how you program their logic. 

As per its design goal of making the process of creating your services/tasks as simple as possible, Sparts is implemented with an abstraction model such that there is a main service class and a main task class that you as the developer will subclass from to make your service(s) and task(s). The parent classes are written such that once subclassed, all you have to do is “fill in the blanks” with the logic of your tasks and services by overriding specific methods of the parent (or superclass). These methods are pre-defined but typically contain no logic, as that is what you are supposed to implement in your specific instance of the task.

In this manner, the typical work flow is to create a new task class that inherits from the main task class, otherwise known as subclassing the main task class. Note that there are actually two main common ones, but we’ll get to that later after we talk about the work flow. Then, you define the logic of that task by overriding the “execute” function that was defined as an empty function in the parent task class. After defining your task(s), you will create a new service class that inherits from the main service class (called “VService”) and then define a class list variable inside of it called TASKS, with each of your tasks as the list items. Then, all you have to do is run your service and it will handle running your tasks correctly as you’ve specified. 

You fill in the blanks for the logic behind each of your tasks, add them to a service’s list of tasks, and boom- you’re off to the races.

A little more about the different Task classes that are available: the most commonly used Task classes are either “PeriodicTask” or “QueueTask”. As their names suggest, PeriodicTask is the class you want to subclass from if your task is to run at regular intervals, and a QueueTask is the class you want to subclass if your task is to perform a bunch of operations in a given order. From there, the work flow for using these Task classes is exactly the same as described above.

[hackedu-blog1]

How to Think About Cooking Meat in the Oven, Generally

A useful mental model to understand as you think about how you’d like to oven cook your next large slab of meat. 

First, let’s establish a general range of temperatures you’re going to be cooking meat in:

The average or normal temperature for baking things in the oven is 350 degrees- which is why for most ovens, this is the default temperature when you first turn it on to bake mode. From there, the low end of the scale is around 290/300 degrees (considered low heat) and the high end is around 400-425 degrees fahrenheit (considered high heat).

Next, consider the meat you’re cooking:

Different cuts of meat will have different textures and different cooking times. Generally, the thicker the meat is the longer it will take for the heat to penetrate the centre such that you have an evenly / thoroughly cooked piece of meat (if that is your goal). There are things you can do to your meat to help alleviate this, cutting incisions into the meat slightly to allow the heat to more easily penetrate for example, or - commonly with pork chops - physically beating the meat in order to tenderize it first by break up the proteins with brute force. Also there is always the option of cutting the meat into thinner slices. Remember, cooking is basically a chemical reaction and from high school chemistry, increasing surface area (ie. cutting into more slices) is a way to speed up a chemical reaction (ie. reducing cooking time in our case).

Then, meat juices:

The common red meats (ie. pork, beef, lamb) are typically considered to have “juices” that chefs commonly place emphasis in retaining inside the meat, particularly when roasting a large chunk of it in the oven. I am unsure if this is because the juices provide more flavour if retained or if it is because they simply don’t want the meat to dry out (perhaps both), but it is typically an important consideration. Most commonly, this involves searing (thoroughly cooking) the outer layer of the meat quickly with very high heat first before allowing the entire chunk of meat to cook at a lower temperature over time (to allow the heat to penetrate and cook the inside of the meat chunk). 

Some juices will inevitably leak out though- this is what is typically used as a extremely flavourful base to make gravies or other sauces to either go with the meat when you serve it, or it can be used as a stock for future dishes.  yum yum!

And finally, oven placement:

Conventional kitchen ovens come with two racks inside, thus allowing you to place your meat closer to the top of the oven or the bottom of the oven. In most cases, it is impossible for the heat signature / profile of the oven to be constant throughout the entirety of its volume, thus the meat may cook differently depending on where you place your meat inside the oven. The top of the oven is typically considered to be the hottest as that is where the hot air will concentrate. Newer, modern ovens have “convection” features that will circulate the hot air inside the oven with the goal of creating a more even heat distribution inside it, but this is still imperfect. 

[hackedu-blog1]

Why, JavaScript, Why?

Today marks the day that I discovered my first JavaScript quirk that made me think, “wait this makes no sense. why, javascript, why?”.

I had heard rumours, whispers from the masses about how “JavaScript makes no sense”. But today I experienced this for the first time.

If you want to select an HTML element by its ID, JavaScript handily provides a getElementById function for you to use. Similarly, there exists a getElementByClassName function to use if you instead want to identify a given element by its class instead of its ID. The interesting thing is that while getElementById will return the element (makes sense, right?), getElementByClassName returns an array of size 1, containing the element. This in practice does not complicate things a whole lot as the only difference is that in actuality, getElementById is really comparable to getElementByClassName[0], however it makes you wonder....why, JavaScript, why?

[hackedu-blog1]

Stack Frames

DRAFT: When an application runs, the operating system allocates memory for the application to use. This is referred to as the "memory stack" for a given app. Every time a function in the applications' code is called, that function is given access to part of that memory stack. When this happens we say that the function is given a frame of the stack, or that each function is given a stack frame.

[hackedu-blog1]

‘Super’ in Python

The ‘super’ keyword was introduced in around Python 2.3 and solves the problem of ambiguous method definitions when a class inherits from multiple parents.

Say for example the child class would like to access a method that belongs to its parent class. This seems fairly straightforward when the inheritance is singular (one parent class to one child class), however we run into problems if that child class inherits from more than one parent. What if the name of the method that the child is interested in exists in both of its parents?

The super keyword abstracts away the need to solve this ambiguity to Python’s built in algorithms. These algorithms will order the inherited methods in a priority queue (known as the Method Resolution Order, or MRO) which will dictate the order that the methods are inherited by the child class. Instead of explicitly calling the method on the parent class, one simply uses the super keyword to call the method and it will figure out the correct superclass method to use.

[hackedu-blog1]

Kitchen Knives 101- Overview

I’m home for the holidays! And our kitchen at home is in need of a new kitchen knife (just in time for boxing day)! So I spent some time looking into what kind of knife to buy. There are many types of kitchen knives, but we will focus specifically on an all-purpose chef’s knife.

Turns out most of the world’s kitchen knives are made by German or Japanese companies, typically with a long standing history in the industry. That doesn’t necessarily mean that the knives themselves are always manufactured in Germany or Japan, but that is where the companies were historically founded and headquartered. (This subliminally implies that it is “better” when the knives are produced in their respective home countries, so you are charged a premium for it!)

Some of the companies from Germany include: Henckels and Wusthof (known as the “Big Two”).

German blades were historically known to be more hefty in weight, have a more curvy blade profile. Japanese blades were historically characterized by being thin, light weight and having a more straight blade profile. The thin-ness of the blade allowed it to be made very sharp. However at the same time, this meant that Japanese blades are not suited for slicing through dense or tough food ingredients. 

In modern times, German manufacturers have adopted a “hybrid” form of knife, which combines characteristics of both, called the “santoku” style of kitchen knife. These knives typically also sport grooves along both sides of the blade called a granton edge that reduce the surface area of the blade’s side that contacts the food, thus preventing foods from sticking to the side of the blade as easily.

Beyond these general characterizations, what really matters most is the feel of the knife in the hand of the chef. Overall weight, distribution of that weight over the entire blade (ie. the balance of the knife), the shape of the grip, the length of the grip, the length of the blade. All of these things factor into how a knife feels. The easiest way to tell is to hold one in your hand and do some mock strokes with it. Ideally you’d be able to test the blade out on actual food ingredients, however most places I have encountered do not allow you to do this, understandably! 

For more information, check out: http://kitchenknifeguru.com/knives/how-to-buy-a-great-chef-knife/

[hackedu-blog1]

Underscores in Python

A summary of a fantastic blog post I stumbled upon today, that explains this in detail oh so well.

Python does not truly implement the idea of private methods, however the closest it gets is to preface a function name with a single underscore, to denote that the given function should not be accessed.

Prefacing a class’ method name with a double underscore is to prevent the function from being over-ridden when subclassing from that given class.

Surrounding a method name in double underscores, (ie. __this__) denotes a function that is to be called by the Python interpreter and is not to be accessed ever by you!

PS. Merry Christmas, to all of you celebrating today!

[hackedu-blog1]

Essentialism, the Way of Optimal Focus

The other day, one of my good friends from school recommended I read Essentialism by Greg McKeown and I finally got to going through it. It preaches the practice of constantly removing the non-essentials from one’s life such that they will be freed to focus entirely on the essentials- the things you believe truly matter. 

Its four main tenants are:

Do less, but do them better.

Accept that you should not try to accomplish everything. In attempting to do so, all you will accomplish is being mediocre at everything, at best. At worst, you will simply fail at everything.

Constantly verify your goals, chosen path and purpose, inflect and reflect, and update your plans accordingly. Give yourself the time, space, quiet and calm to do this.

Once decisions are made, take immediate and decisive action.

One of my personal key takeaways from the book however, was the idea of not falling into the sunk-cost bias, which is the tendency to continue investing resources and energy into something we know is unlikely to succeed already. The key to avoiding this is to develop the courage to admit past errors and mistakes and being able to let them go. 

If it is clear that something isn’t going to work out, don’t be afraid to cut your losses and abandon ship.

Some other key points:

Do not be complacent and always take an active approach to making choices with respect to what one does with their life. Do not lose control of the ability to choose what one does and how they spend their time through learned helplessness (ie. becoming too accustomed to being overwhelmed, seemingly for no reason, that you approach life with passivity).

The “choice” described above can be considered as simply as what things we say ‘yes’ to doing and which things we say ‘no’ to doing. When deciding, one must be ruthless in deciding which things are truly vital. It is better to focus and do one vital thing very well than to do the vital thing along with other unimportant things, all mediocrely.

To enact real, powerful changes over time, habit is a powerful tool for they can provide small incremental progress done over time. Small incremental progress allows for one to check whether or not you are heading in the right direction, and allows you to build momentum to succeed further. In order to develop new habits, one requires a routine. Create a routine that aligns with your goals and be disciplined in sticking to it.

And finally, the key message of the book can be summarized as:

Only a few things are ever truly vital to our goals and well-being. Everything else is unimportant. By focusing en these few essential things and learning to do better by doing less, we can craft a life that is far more productive and fulfilling.