text:
# Change Log
All notable changes to this project will be documented in this file.

## Unreleased
No unreleased changes.

## 0.4.1 - 2016-08-16
### Added
- New Rivets formatters: `times`, `divided_by`, `modulo`

### Changed
- Fix issue with unnecessary line item properties being added with form submit

## 0.4.0 - 2016-02-11
### Added
- New Rivets formatter: `array_element`, `array_first`, `array_last`
- CONTRIBUTING.md
- Simple Mocha-based test framework
- `pluralize` formatter
- `slice` formatter

### Changed
- Fixed jQuery dependency from load-time to run-time

### Removed
- IE8 Compatibility mode

## 0.3.9 - 2015-11-11
### Added
- Two new Rivets formatters: `includes` and `match`

## 0.3.8 - 2015-10-27
### Added
- `cart.ready` event, fired after initialisation finishes.

## 0.3.7 - 2015-10-26
### Changed
- `getImageSizedUrl` filter now handles empty product images.

## 0.3.6 - 2015-10-24
### Added
- New weight formatters `weight` and `weight_with_unit`, with corresponding
  settings `weightUnit` and `weightPrecision`.

## 0.3.5 - 2015-08-04
### Added
- Include non-minified version of `rivets-cart.js` in `dist`

## 0.3.4 - 2015-07-16
### Added
- Minor `console.log` compatibility fix for IE8 and IE9 browser support

## 0.3.3 - 2015-07-04
### Added
- Compatible version of `rivets-cart.min.js` for non-ES5 browser support

## 0.3.2 - 2015-07-03
### Added
- Made `getCart` a public method to allow force cart refreshes

### Changed
- Fix for missing `removeItemById` public method

## 0.3.1 - 2015-06-28
### Changed
- Fix for undefined Currency issue if not using Currency plugin.

## 0.3.0 - 2015-06-27
### Added
- Support for dynamically rendering currency changes through money filters

### Changed
- Upgraded Rivets.js library to v0.8.1

## 0.2.7 - 2015-05-18
### Added
- Add `debug` setting for outputting of useful information to the console

## 0.2.6 - 2015-04-02
### Changed
- Fixed incorrect method call when un-checking a checkbox using `data-cart-toggle`

## 0.2.5 - 2015-04-01
### Added
- Add `prepend` and `append` formatters to Rivets

## 0.2.4 - 2015-03-13
### Added
- Ability to specify callbacks through an `options` hash argument in Core API

## 0.2.3 - 2015-02-25
### Changed
- Fixed potential issue using .data() instead of .attr() to access `data-` attributes
- Added quantity adjustment example to advanced code example

## 0.2.2 - 2015-01-25
### Added
- New `updateItemQuantitiesById` Core API method

## 0.2.1 - 2014-11-27
### Added
- This new-format CHANGELOG, based on http://keepachangelog.com

### Changed
- Further improvements to documentation, including better code examples

## 0.2.0 - 2014-10-11
### Added
- New Data API methods for updating and clearing items
- New `data-cart-render` methods for simple DOM updating

### Changed
- Major improvements to documentation

### Removed
- `getCart()` method no longer publicly exported

## 0.1.0 - 2014-10-09
### Added
- Initial implementation; first "official" release
- Core API
- Data API
- Rivets.js DOM bindings

repository: JamesLinus/cartjs

repo_name: JamesLinus/cartjs


text:
# plug-and-blend

This is the official repository for implementation of https://arxiv.org/abs/2104.04039

# See the demo now!

(Hint: Don't forget to switch Runtime Type to GPU)

Codebase for public release of the plug-and-blend framework.

license: MIT

branch_name: refs/heads/main

extension: md

gha_license_id: MIT

license_type: permissive


text:
# Certificate Generation and Validation
This is a tool that can be used to generate and validate certificates. Some scenarios can be covered

For certificate generation
- Client and Server
- Browser and Apache
- Client, Server and f5 HW load balancer that is deployed between client and server

For certificate validation
- Client and server
- Common Access Card

repository: lizwjiang/cgv

branch_name: refs/heads/master

repo_name: lizwjiang/cgv


text:
---
layout: article
title:  "Rango “Cactus Makes Perfect” Game"
date:   2011-01-14 14:02:42
categories: [games]
tags: [AS3, robotlegs, subversion, tweenMax]
image:
  feature:
  teaser: portfolio/rango-game-teaser.jpg
---

Technology: Flash, ActionScript 3, OOP, MVC, RobotLegs

URL: [WWW](http://www.rangomovie.com/intl/uk/cactusmakesperfect/)

Agency:[ MarsLight](http://www.marslight.co.uk/) /[FireBelly Creative ](http://firebellycreative.co.uk/)

My work/Main features :

- Programmed and designed game logic
- Developed using AS3 RobotLegs framework
- Imported and processed all vector and raster assets from Photoshop/Illustrator

![Rango game screen 1](/images/portfolio/rango-game-1.jpg "Rango game screen 1")

repository: wajerrr/pixelsoup

repo_name: wajerrr/pixelsoup


text:
---
title: withFallback.ts
nav_order: 31
parent: Modules
---

# withFallback overview

Added in v0.5.0

---

Table of contents

- [withFallback](#withfallback)

---

# withFallback

Returns a clone of the given codec that always succeed using the given value `a` if the original codec fails

**Signature**

```ts
export function withFallback<C extends t.Any>(codec: C, a: t.TypeOf<C>, name = `withFallback(${codec.name})`): C { ... }
```

**Example**

```ts
import { withFallback } from 'io-ts-types/lib/withFallback'
import * as t from 'io-ts'
import { right } from 'fp-ts/lib/Either'

const T = withFallback(t.number, -1)

assert.deepStrictEqual(T.decode(1), right(1))
assert.deepStrictEqual(T.decode('a'), right(-1))
```

Added in v0.5.0

repository: gcanti/io-ts-types

gha_language: TypeScript

repo_name: gcanti/io-ts-types


text:
---
title: Wiki rules and etiquette
category: help
authors: daejohnson, quaid
---

<!-- TODO: [Mikey] Update this page for contributing to content on GitHub -->

# Wiki rules and etiquette

This page sets out general guidelines for the oVirt project wiki.

There are a few simple points you should follow as you make changes to the wiki. Below are some examples. In general, be courteous and use common sense. Defying these guidelines and causing problems are a good way to get your edit privileges revoked. If you have questions, you can ask on #ovirt on [OFTC](http://oftc.net/) or [arch@ovirt.org](http://lists.ovirt.org/mailman/listinfo/arch).

## Introduce yourself

Before you start editing any page, kindly introduce yourself by adding your information to your wiki page. After you have registered your name in the wiki, you automatically have a personal wiki page located at `<nowiki>http://ovirt.org/wiki/User:</nowiki><username>`, where `<username>` is replaced by your oVirt wiki account name. You can also easily get to your wiki page by clicking your username in the top right-hand corner of each page of the wiki.

For examples, take a look at [<http://ovirt.org/w/index.php?title=Special%3AAllpages&from>=&namespace=2 some wiki pages of our contributors]. *This link is broken, but I dont' know where to point it. --daej (daejohnson)*

On your user page, make sure you mention at least your email address and, if you are on IRC often, your IRC nick and channel(s) you are often in.

## Always watch pages that you create or edit

It is important that you follow changes to pages you create or edit, so you can coordinate with others working in the wiki content. Wiki editors usually add notes to the pages to convey information to each other as part of working together, and it helps to keep track of these changes.

You can find the **watch** link in the tab bar at the top of a page when you are logged in.

You can set all pages that you create or edit to automatically be put in your watchlist with this procedure:

1.  Go to <Special:Preferences>.
2.  On the *Watchlist* tab under *Advanced options* put a checkmark next to these items:
    -   *Add pages I edit to my watchlist*
    -   *Add pages I move to my watchlist*
    -   *Add pages I create to my watchlist*

## Be Bold

Be **bold** while editing changes. Wiki changes are tracked and can be reverted when necessary. This doesn't mean you should be reckless, especially when making large changes to key documents.

For more information on being **bold**, take a look at the [be **bold** editing guideline on Wikipedia](wikipedia:Wikipedia:Be_bold).

## Avoid unnecessary edits of pages that discuss legal issues

These pages have been carefully written, and the words chosen carefully. When changing these documents, it is usually best to ask for review before applying changes. You can contact the [oVirt project board](/community/about/contact/) for assistance.

## Be careful when editing key guides or pages

Large and important guides are generally managed by a specific individual or small group. It is best to work with them when you feel that changes are needed.

Important pages, such as the [Main Page](/), are the first thing that many visitors see. Changes to such pages should generally be left to experienced contributors. If you feel that something on such a page should be altered, bring the issue to the [arch@ovirt.org](/community/about/contact/) mailing list for discussion.

## Do not edit pages just to edit pages

Senseless edits should be avoided. Making an alteration to a page just to put your name in the edit log is unacceptable. There are plenty of pages (most of them, in fact) that have real errors that can be corrected. Instead of making pointless edits, such as removing or adding whitespace or changing links from ovirt.org to www.ovirt.org (the former is preferred), try finding errors in spelling, grammar, or punctuation that can be corrected. Also, when correcting a small error, mark "This is a minor edit" using the appropriate checkbox before you save it.

## Avoid renaming pages or moving content without coordination

Wiki pages are generally referred to and linked to from various other locations. It is important that you coordinate with the appropriate groups before moving content or renaming existing pages. It would be better to avoid doing that without strong rationale. If you wish to discuss moving a particular item, bring your questions to the [arch@ovirt.org](/community/about/contact/) mailing list.

## Deleting Pages

Wiki pages that are no longer needed can be tagged for deletion by adding {{Delete|Reason}} to the beginning of the page, this gives Wiki Administrators the ability to ensure that important or archivable content is not lost.

## Sign your attachments

When you attach a file to a wiki page, you should create a detached signature with your GPG key. Some file formats, such as RPM packages, support GPG keys, in which case you do not need to create a detached signature -- a signature in the file will be enough. A detached signature can be attached to the page alongside the original attachment, or can be included in the page itself.

GPG signatures allow others who download your file to verify that it came from you and has not been modified or corrupted. They do not violate your privacy in any way, they simply allow others to have confidence in the origin of your files.

Images and simple documents are safe to leave without a signature, but there would be no harm in adding one anyway to verify that you were the author.

## Review your changes for errors

Whether you are a skilled writer, or your English skills are not strong, invite someone else to review. Well-written documents are important to oVirt's image. Even the best writers are prone to typos or other errors. Take a moment to review your changes to catch small errors. Use the **Show preview** button when editing a page to check your syntax.

## oVirt is a community

When writing content, for the wiki or elsewhere, remember that oVirt is a community. *We* operate as one, unified group, moving towards common goals. *We* do not need to distinguish one group or class against another. For example, there is no need to distinguish between contributors who work for a company and those who do not. All contributors are part of the same community. There will be cases where classification is necessary, but it can be avoided otherwise.

## If you aren't sure about something, feel free to ask

Other community members will be happy to assist you. The #ovirt channel on [OFTC](http://oftc.net/) is the perfect place to discuss the wiki.

## Watch your pages, and other ones, too

Two details make a Wiki successful as an open content collaboration tool. First is being able to watch content you are responsible for, to make certain it stays true to its mission. Second is being able to watch other content develop, grow, and occasionally need your help.

To watch any page on the wiki, after logging in, click the **watch** link in the tab bar at the top of a page. It should change to **unwatch** after it has finished. If a page has **unwatch** at the top, you are already watching that page. You can click **unwatch** to unwatch a page.

To receive emails for every edit, go to **my preferences (Preferences)** (at the top of the page by your name) and make sure to check the appropriate boxes in the **User profile** tab, under **Email**.

#### Using Special:Watchlist

<Special:Watchlist> (available by clicking **my watchlist** at the top of each page when you are logged in) displays pages you are currently watching. For more information on how to use this special page, refer to [the manual page at Mediawiki.org](http://www.mediawiki.org/wiki/Manual:Watchlist).

## Summarize your changes (aka commit log message) -- this is the rule

We all need to be able to quickly glance at a change and know the substance of it. A full diff is not always available. You must supply a summary of your change (*Summary:* field when editing). This is akin to a changelog message. Explain what you did and why, as well as other useful links and details.

If you choose to not put in a summary, it should be the rare exception. One reason is when doing a minor edit. In that case, be sure to check *This is a minor edit* when saving.

*(Content from <https://fedoraproject.org/wiki/Help:Wiki_rules_and_etiquette> under [CC BY SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/))*

repository: msbai/ovirt-site

repo_name: msbai/ovirt-site


text:
# Tutorial
For this tutorial to work, you need a proper xyz file (one is provided in this directory).

Furthermore, the installation must have been done properly (your PATH should contain the directory where the
python programs ims3d.py, ims3d_harv.py and ims3d_view.py are located) and the dependancies fullfiled.

## Naphtalene with default grid and 1 angström radius surface

1. Generation of the com files

```
ims3d.py -r 1 naphtalene.xyz
```

2. Gaussian calculation

2.1. Transfert of the _com_ files to the cluster (if needed)

```
scp *.com REMOTE_MACHINE:INPUT_PATH
```

2.2. Run gaussian on all _com_ files

#  ☕☕☕

2.3. Transfert of the _log_ files back from the cluster (if needed)

```
scp REMOTE_MACHINE:INPUT_PATH/*.log .
```

3. Gathering of the computed IMS

```
ims3d_harv.py input_batch_00000.log
```
4. View of the results
```
ims3d_view.py
```
When a window pops u, press "q" to exit.
Viewing can be done with different rendering (run ims3d_view -h for available options)

repository: R-Laurent/detection

repo_name: R-Laurent/detection


text:
---
title: Welcome!
teaser: The start of something new!
category: misc
tags: [blog, misc]
published : true
---

## PowerShell Intro Delivered by the Spooky Skeleton

I wanted to finally do something with this idea to start keeping some of my findings in a place where I or others could find them easily.

![Welcome]({{ site.baseurl }}/images/2017-1-8-Hello-World/HelloWorld1.PNG)

To start off I wanted to greet everyone with one of my favorite dopey ASCII art images *(with some additional greetings instead of the usual chain mail message)*.

I can tend to be kind of a no fun stiff sometimes with PowerShell code style and PSScriptAnalyzer rules and in true honor of that I chose to `Write-Output` instead of `Write-Host` *(something, something, something dead puppies...  Yes I know PowerShell v5 changed its behavior...)*.

This brings me to my first *real* post idea which is a write up of my favorite free PowerShell resources, one of which is the PoshCode style guide.  I had this idea after posting a reply on ([/r/PowerShell][PowerShellReddit]) asking about a favorite book/training course on PowerShell.  It won't be limited to just style and rules, I also want provide some good resources for folks just getting started as that is a question I also see frequently on Reddit and from colleagues.

Oh yeah... I haven't decided on a theme, and I am also notorious for making tons of small edits, so I forsee many commits/updates to this in the future.

Update 4-22-2018[^1]

---

[^1]:
    I went through a big update in April 2018, this article was moved as part of that!

[PowerShellReddit]: https://www.reddit.com/r/PowerShell/


text:
---
layout: post
title: "More Clean Tests: Handling Mocks & Block-based asserts"
date: 2012-01-16 11:58
comments: true
categories:
---

In a [previous post][cleantests], I talked
about the overall structure of a test and how that was important to understand the test itself.  A brief review:

* *Given* - Establish the conditions under which the test will run
* *When* - Run the code under test
* *Then* - assert that the code did what you expect

This structure becomes problematic when using either mock objects or block-based asserts.

<!-- more -->

## The Trouble with Mocks

When using [mock objects][mocks] in a test, you typically use a
mocking framework (like [mocha][mocha]) to modify the behavior of objects the class-under-test collaborates with.
You often test that the class-under-test made certain calls to its collaborators.  Let's look at an example.

Suppose we have an existing system and we wish to start recording some statistics, such as the number of times a method is called
or how long a method takes to run.  We've created a class, `Statistics`, that has some class methods on it to do the recording:

```ruby Statistics class outline
class Statistics
  # Add one to stat_name
  def self.count(stat_name)
    # ...
  end
end
```

We want to start using this class in our `Salutation` class to keep track of the number of times we're calling `#greeting`.
In order to add this in, we need to test that `Salutation#greeting` is calling `Statistics.count`.  While we could set up a fake
statistics server and examine it during our test, it's more straightforward to use mocks.

```ruby Testing the use of Statistics
class SalutationTest << TestCase
  def test_that_we_log_statistics
    saluation = Salutation.new(Person.new('David','Copeland',:male))
    Statistics.expects(:count).with('saluation.greeting.count')
    saluation.greeting
  end
end
```

What will happen is, if we don't call `Statistics.count("saluation.greeting.count")` in the `Salutation` class, this test will
fail.  That's what a mocking framework like mocha does for us.

Of course, there's something odd about our test.  There's no call to any sort of `assert` method.  The Given/When/Then is very
unclear.  For a real-world test that requires a lot more setup, it can be even more difficult to see what's actually being
tested.  Essentially, the "Given/When/Then" is "out of order":

```ruby 'Then' and 'When' inverted
class SalutationTest << TestCase
  def test_that_we_log_statistics
    # Given
    saluation = Salutation.new(Person.new('David','Copeland',:male))
    # Then
    Statistics.expects(:count).with('saluation.greeting.count')
    # When
    saluation.greeting
  end
end
```

## Making our Intent Clear

We'd like to keep our test method in a canonical structure, or at least have some part of it follow the Given/When/Then
structure.  Unfortunately, our "Then", the mock expectations, simply _have_ to occur _before_ the "When".  I think
we can make it clearer, so let's add a bit of code to help.

First, we'll create a method named `when_the_test_runs_then` to clearly indicate that our expectations
are part of our "Then", and that they are going to be checked when the test runs, which happens later.  We'll also add a no-op
method, `assert_mocks_were_called` that will allow our test to always have an assert and provide us with a way to be explicit
about what's being asserted.  Although this "assert" method doesn't do anything, it allows use to distinguish between "this test
passes when the mocks are called as expected" from "I forgot to actually test for something".

```ruby 'Then' and 'When' inverted
class SalutationTest << TestCase
  def test_that_we_log_statistics
    when_the_test_runs_then {
      Statistics.expects(:count).with('saluation.greeting.count')
    }

    # Given
    saluation = Salutation.new(Person.new('David','Copeland',:male))
    # When
    saluation.greeting
    # Then
    assert_mocks_were_called
  end

  def when_the_test_runs_then; yield; end
  def assert_mocks_were_called; end
end
```

We've still deviated from our canonical structure, but the test _reads_ better: "When the test runs then expect this method to be
called; now let's run the test"

Of course, we've just taken our first step out of "plain old Ruby" and created framework code.  This is the price you pay for
using mocks; testing with mocks complicate our tests.   By using some lightweight "control structure" helper methods, we can at
least make the intent clear.

## Block-Based Asserts Disrupt, too

There's another pattern we see in tests that disrupts the structure in much the same way that the use of mocks does.  That
disruption is block-based asserts, the most common of which is `assert_raises`.  For example, suppose we're testing that our
`Saluation` class requires a non-`nil` `Person` in its constructor.  We could test that like so:

```ruby Testing that code raises an Exception
def test_that_constructor_requires_a_person
  assert_raises ArgumentError do
    Salutation.new(nil)
  end
end
```

This test is weird for two reasons: the first is that the "Given" is implicit.  The second is that the "Then" comes before the
"When":

```ruby The Given/When/Then of our block-based assertion test
def test_that_constructor_requires_a_person
  # Given - we are going to use a nil Person
  # Then
  assert_raises ArgumentError do
    # When
    Salutation.new(nil)
  end
end
```

We can clean this up by creating a variable for our `nil` `Person` and putting our "Then" code inside a block, which we then pass
to `assert_raises`:

```ruby More clear test with block-based assertions
def test_that_constructor_requires_a_person
  # Given
  nil_person = nil
  # When
  code = lambda { Salutation.new(nil_person) }
  # Then
  assert_raises(ArgumentError,&code)
end
```

We've had to jump through a slightly awkward hoop of putting the code-under-test in a lambda, but now things are in a consistent
structure.  This example might seem a bit too simplisitc.  What about another popular block-based assertion, `assert_difference`?
It's commonly used in Rails apps to check that a certain number of records were written to the database.  While I think that this
assertion is generally not needed, it is commonly used.
Here's an example where we suppose that an `after_save` hook is memoizing a
derived field for us.

```ruby Complex test using assert_difference
test "we can save and our after-save hook runs, generating the full_name attribute" do
  # Given
  first_name = 'David'
  last_name = 'Copeland'

  # Then
  assert_difference('Person.count') do
    # When
    person = Person.create(:first_name => first_name, last_name => last_name)
    # Then
    assert 'David Copeland',person.full_name
  end
end
```

*Now* the structure is very strange.  If we try to apply our `lambda` solution above, it's still a bit odd:

```ruby Applying a lambda to our Rails test
test "we can save and our after-save hook runs, generating the full_name attribute" do
  # Given
  first_name = 'David'
  last_name = 'Copeland'

  # When
  code = lambda {
    person = Person.create(:first_name => first_name, last_name => last_name)
    # Then
    assert 'David Copeland',person.full_name
  }

  # Then
  assert_difference('Person.count',&code)
end
```

Yikes.  This is arguably worse.  Since only one line of code inside our "When" block is really affecting the condition that
`assert_difference` tests for, we can take advantage of Ruby's ability to create instance variables on-demand and pass
the person outside of the `assert_difference` block:

```ruby Canonically-structured Rails test using assert_difference
test "we can save and our after-save hook runs, generating the full_name attribute" do
  # Given
  first_name = 'David'
  last_name = 'Copeland'

  # When
  create_person = lambda {
    @person = Person.create(:first_name => first_name, last_name => last_name)
  }

  # Then
  assert_difference('Person.count',&create_person)
  assert 'David<EMAIL_ADDRESS>end
```

That's much better; we can now clearly see the setup, the code being tested, and all the assertions together.

It may seem slightly unusual, but by working to keep all your tests structured around Given/When/Then, you will find them
readable weeks and months later, and others will be clearly able to see their intent.

## Next

We still have a fair way to go to get our tests really clean and clear.  For example, do we need to have those `#Given`, `#When`,
and `#Then` comments
everywhere?  I [think comments are powerful][commentspost], but having the same group of comments everywhere
feels like repetition we can eliminate.
Another issue is the use of "magic values", or literals, in our test code.  In the test above, we create a male person with the
name "David Copeland".  Is any of this relevant to the test?  If not, why is it there?

We'll deal with these issues in the next post.

[cleantests]: http://www.naildrivin5.com/blog/2012/01/08/make-tests-clean-and-clear-without-duplication.html
[mocks]: http://en.wikipedia.org/wiki/Mock_object
[mocha]: http://mocha.rubyforge.org/
[commentspost]: http://www.naildrivin5.com/blog/2012/01/11/the-war-on-comments.html

extension: markdown


text:
# BreakPoint
iOS text-based Social Media app written in Swift 4 using Firebase

## Preview
![Alt Text](https://media.giphy.com/media/ZFuEc2iBRJWh2qRDFR/giphy.gif)

**Built with**
- Ios 11.3
- Xcode 9.4

## Features
- **Post text that is instantly sent to ```Realtime Database``` and received instantly to chat with friends in real time.**
- **Create private Groups, and group messages**
- **Add a profile image using ```Firebase Storage```**
  ```swift
  let picker = UIImagePickerController()
  ```
- **Create a custom user biography**
- **Login using ```GoogleSign``` or ```Email```**
- **Logout with ```UIAlertAction```**

## Requirements
```swift
import Firebase
import FirebaseStorage
import GoogleSignIn
```

**_Pod Files_**
```swift
pod 'Firebase/Core'
pod 'Firebase/Database'
pod 'Firebase/Auth'
pod 'GoogleSignIn'
pod 'Firebase/Storage'
```

## Documentation
- [Firebase Setup](https://firebase.google.com/docs/ios/setup)
- [Authentication](https://firebase.google.com/docs/auth/ios/start)
- [Google Sign In](https://firebase.google.com/docs/auth/ios/google-signin)
- [Realtime Database](https://firebase.google.com/docs/database/ios/start)
- [Storage](https://firebase.google.com/docs/storage/ios/start)

## Project Configuration
You'll have to configure your Xcode project in order to run the samples.

1. Your Xcode project should contain a ```GoogleService-Info.plist```, downloaded from ```Firebase console``` when you add your app to a Firebase project.

2. Update URL Types.
  Go to ```Project Settings -> Info tab -> Url Types``` and update values for:
  ```REVERSED_CLIENT_ID``` (get value from ```GoogleService-Info.plist```)

3. Configure your Firebase App Database using Firebase console.
Database should contain appropriate read/write permissions and folders.

4. Enable Sign-In Providers to allow Sign-In Methods
   ```Firebase console -> Project Name -> Develop -> Authentication -> Sign-in method```
   Enable: ```Email & Google```

### Credits
Devslopes Firebase Tuts

## License
Standard MIT [License](https://github.com/johnnyperdomo/BreakPoint/blob/master/LICENSE)


text:
# Silverstripe placeable quotes

## Installation
Composer is the recommended way of installing SilverStripe modules.
```
composer require silverstripe-modular-project/silverstripe-placeable-quotes dev-master
```


text:
# Project name:
> Your project’s name is the first thing people will see upon scrolling down to your README, and is included upon creation of your README file.

## Todo Restul Api

# Description:
> A description of your project follows. A good description is clear, short, and to the point. Describe the importance of your project, and what it does.

Todo is a Restful webservice designed to assist users with building their own Todo application. This service will provide various methods and available calls to accommodate general uses of a Todo task list.

## Features
This project provides API endpoints to operate CRUD functionality to manage a personal To Do list:
* Add daily tasks with due date
* Add contact information and reminder for important phone calls
* Keep track of items you want to purchase
* Maintain a daily or weekly routine by recording your Todo session
* Make a list of groceries to help you save time at the store, save a list for next time

# Table of Contents:
> Optionally, include a table of contents in order to allow other people to quickly navigate especially long or detailed READMEs.

# Installation:
> Installation is the next section in an effective README. Tell other users how to install your project locally. Optionally, include a gif to make the process even more clear for other people.

# Usage:
> The next section is usage, in which you instruct other people on how to use your project after they’ve installed it. This would also be a good place to include screenshots of your project in action.

### MongoDB:
- Add your IP Address to the Network Access
  * Log into account, click Network Access on left navigation
  * Click 'ADD IP ADDRESS'

### Visual Studio Sln:
- Add MongoDB password to the Environment variable
  * Use label 'MongoDB_Password'

# Contributing:
 > Larger projects often have sections on contributing to their project, in which contribution instructions are outlined. Sometimes, this is a separate file. If you have specific contribution preferences, explain them so that other developers know how to best contribute to your work. To learn more about how to help others contribute, check out the guide for setting guidelines for repository contributors.

This has been initiaited by a group of 3 developers. Your feedback in appreciated and encourage in how to improve. This service is limited to the available endpoints that we were able to think of and build. We welcome ideas to provide more options and features.

# Credits:
> Include a section for credits in order to highlight and link to the authors of your project.

# License:
> Finally, include a section for the license of your project. For more information on choosing a license, check out GitHub’s licensing guide!

> Your README should contain only the necessary information for developers to get started using and contributing to your project. Longer documentation is best suited for wikis, outlined below.

gha_language: C#


text:
# Website-html-css
A website example made in HTML5 + CSS3

# Screenshots
![Screenshot-News](https://github.com/LeonMarqs/website-html-css/blob/master/Site%20Not%C3%ADcias%20(HTML%2BCSS)/imagens/screenshot.png)

![Screenshot-News](https://github.com/LeonMarqs/website-html-css/blob/master/Site%20Not%C3%ADcias%20(HTML%2BCSS)/imagens/screenshot2.png)

![Screenshot-News](https://github.com/LeonMarqs/website-html-css/blob/master/Site%20Not%C3%ADcias%20(HTML%2BCSS)/imagens/screenshot3.png)

repository: LeonMarqs/noticias-cidade

repo_name: LeonMarqs/noticias-cidade


text:
# `v0.1.0.pre.5`

* add gem{`rubocop`}
* add a `docker registry service`
* start adding & preparing needed `tooling` for various `CICD methodologies`
* for `docker images`, begin better utilization of `docker tags` to enable a more hierarchical design
  * (enabling more `layer caching`, `code re-use`, reducing `build times`, etc)
* start formal division between `Ruuuby` as a `gem` and as a `stateful engine` (latter requiring `gem + git source`)
  * `Ruuuby as a gem` will converge to `TDD` towards {`0.1.0`}
  * `Ruuuby as a stateful engine` to accelerate `ad hoc refactorings & design testing` towards {`0.1.0`}

# `v0.1.0.pre.4`

* continue `DB` migrations
* apply miscellaneous clean ups
* (*unofficially*) add gems{`rails`, `keycutter`, `github-linguist`}
* remove `rng` tests among others while reviewing scope of needed `statistics formulas` and approaches
* start of (critically needed) migration for more formal `CICD`
  * begin preparation for proper git branching w/ `git hooks` on both `client` and `server` side
  * begin preparation for proper build pipelines w/ a hybrid of custom code + a (to be chosen) `CICD` framework(s)
  * iterative refactor of mapping between features & code; `Ruuuby Dockerization` to resume following more cleanup

# `v0.1.0.pre.3`

 * add gem{`open3`}
 * continue `DB` migrations
 * iterative improvement for custom builds, lazy-loading, and separation between `dev`/`test`/`prod` environments
 * apply clean ups, any removed core functionality to return closer to version{`0.1.0`}

# `v0.1.0.pre.2`

 * modify `.gitattributes` to track `.sql` files
 * update gem{`activerecord`}
 * continue `DB` migration
 * apply miscellaneous clean ups

# `v0.1.0.pre.1`

 * start migration from `CHANGELOG.md` to `History.txt`
 * update gems{`tty-command`,`rspec`}
 * continue migration for `RabbitMQ` and `DB`
 * apply miscellaneous clean ups

# `v0.1.0.pre.0`

> abstract: Kintsugi!

 * upgrade to `Ruby` version{`3.0.0-preview1`}
   * gems{`tty-command`, `rugged`} require source code modification for compatibility, alternative solutions to be sought towards end of migration to version{`0.1.0`}
 * better isolate `feature interdependency`, helping `lazy-loading` but also enables setting targeted completion of `Ruuuby Dockerization` for version{`0.1.0`}
   * ⚠: following suite, almost all `DB` related code will finally be getting overhauled (`to re-enable versioning & documentation 'automation' but with more micro granularity covered as to enable smaller code pushes w/o changing time spent on dev`)
 * begin structure overhaul of `commands, tasks, jobs, etc`, functionality designation to be re-balanced amongst `shell scripts`, `Ruby gems`, `Ruuuby scripts`, `RabbitMQ + DB`, etc

> noticeable mentions:

 * add gem{`bunny`} and a `Docker service` to help monitor `RabbitMQ`
 * add gem{`finite-machine`}, apply some design cleanup (w/ lots more to be done)
 * for `web-based services`: add `webmanifest` file and `JSON minification` to the existing `node.js REST end-point`
   * generating file & directory `checksums` also added (wip) w/ results cross-checked between `JS` and `Ruuuby`
 * iterative upgrade for being able to set & apply development preferences such as `OS level configurations`

# `v0.0.49`

> abstract:
 * ⚠: intermediate version release for organizational purposes, many `Classes`/`functions` added are temporary, intentionally created with later removal planned)

> discrete:
 * add `Docker`{`service_js`}
   * create `node.js server`, add first `REST end-point` offering `minification` of `HTML` and `CSS` files
 * add `multi-stage-builds` to existing services
   * add `zsh` to `development-environment` based `images`

> iterative:
 * further organize/upgrade various utility APIs: `git`, `docker`, `zsh`, `brew`, etc
 * further enable `lazy-loading`, lots more to be done
 * for `mac-os`, start utilizing `osascript`
   * (enables niche automation areas, silly ex: compiling w/ voice commands)

| gem updated | version previous | version current |
| ----: | :---: | :---- |
| `docker-api` | `1.34.2` | `2.0.0.pre.1` |

| path added | reference | notes |
| ----: | ---- | ---- |
| `lib/ruuuby/module/bundler.rb` | `Bundler` |  |
| `lib/ruuuby/module/gem.rb` | `Gem` |  |
| `services/web_assets/*` | `multiple files & dirs` | code not directly relating to `ruuuby engine` will not normally be documented (until pending `DB` overhaul) |
| `lib/ruuuby/api/docker/docker_service.rb` | `RuuubyService` | temp util |
| `lib/ruuuby/api/docker/docker_service_set.rb` | `RuuubyServiceSet` | temp util |
| `bin/console_docker` | `RuuubyServiceSetDev` | offers funcs like: `build_web_assets`, `build_js`, `build_html`, `build_css`, `run_dev` |

| for | method(s) added |
| ---: | :--- |
| `Object` | `attribute_versionable` |
| `ENV` | `∀🔑∃_value?` |
| `Hash` | `∄🔑?`, `∀🔑∃_value?` |
| `Array` | `convert_to_json` |
| `String` | `clean!` |
| `Heuristics` | `clean` |
| `Net::HTTPResponse` | `time_received`, `content_length` |
| `💎.engine.api_zsh` | `run_script` |
| `💎.engine` | `run_apple_script!`, `curl_get` |
| `💎.engine.api_locale` | `healthy?`, `healthy_encoding?` |
| `🍺` | `doctor`, `cleanup`, `healthy?`, `analytics?`, `analytics_disabled?`, `analytics_set_on`, `analytics_set_off` |
| `💎.engine.api_git` | `∃index_conflicts?`, `∃fixable_syntax_errors?` |
| ``🐋`/`💎.engine.api_locale.api_docker`` | `∀🐋`, `connected?`, `connect`, `connect!`, `disconnect`, `disconnect!`, `version_compose` |
| `Docker::Container` | `alpine?`, `debian?`, `dev?`, `prod?`, `healthy?`, `env_vars`, `os`, `os_version`, `linux_kernel_version`, `os_architecture`, `mounts`, `∃mount?`, `file_create`, `cmd!` |

---

# `v0.0.48`

 * add initial `Docker services:` {`nginx`, `postgresql`, `pgadmin4`} all `wip` w/ others inc
   * just for development utilities, not anything to be required by gem or for runtime
 * designate feature support/expansion for `WebGL` based derivatives to fully precede over `OpenGL` for `> 95.0% of scenarios`
 * add `RSpec categories:` {`system`}
   * `system tests` for now will act as a combination of `acceptance-testing`, `system-tests`, and `chaos-monkey-testing`
 * apply initial steps for cross-OS compatibility, process of doing so is revealing lots of code areas requiring adjustments, some addressed this version
 * indeterminate hiatus to provide time for math/theory studies to avoid adding tech-debt that would otherwise get created over the next 10+ versions

| gem added | version previous | version current | notes |
| ----: | :---: | :---- | :-----: |
| `pg` | `N/A` | `1.2.3` | comparing (apples & oranges) use-cases against `ActiveRecord` |
| `docker-api` | `N/A` | `1.34.2` | offers tons of functionality, way more to be utilized |

| path(s) added | reference | notes |
| ----: | ---- | ---- |
| `services/nginx/includes/*.nginx` | (multiple files & directories) | |
| `services/web_assets/Dockerfile` | | file added early, will be utilizing various `JS` libs/environments |
| `services/web_assets/ruuuby.html` | | same as above |
| `services/web_assets/ruuuby.js` | | same as above |

| for | method(s) added |
| ----: | :---- |
| `Array` | `∀𝚡λ𝑓🖨` |
| `Hash` | `λ𝑓∀🔑：₍🔑∉₎`, `λ𝑓∀🔑：₍🔑∉₎!` |
| `File::YAML` | `read` |
| `💎.engine.os` | `windows?`, `unix?`, `mac?`, `linux?` |
| `🐋`/`💎.engine.api_locale.api_docker` | `healthy?`, `∃🌐?`, `∃🐋?`, `find_🌐_by_name`, `find_🐋_by_name`, `find_🐋_by_id`, `♻_🌐_by_name` |

---

# `v0.0.47`

| gem updated | version previous | version current |
| ----: | :---: | :---- |
| `rake-compiler` | `1.1.0` | `1.1.1` |
| `rubygems-update` | `3.1.4` | `3.2.0.rc.1` |

| path added | reference | notes |
| ----: | ---- | ---- |
| `lib/ruuuby/math/finance/benchmarks.rb` |  | not currently utilized, just file added early |
| `lib/ruuuby/heuristics/heuristics.rb` | `Ruuuby::Heuristics` | same as above description |

| for | method(s) added |
| ---: | :--- |
| `Matrix` | `ᵀ` |
| `File::CSV` | `read` |
| `💎.engine.api` | `pid_terminate` |
| `💎.engine.api_locale` | `iconv_version`, `iconv_supported_encodings` |
| `PseudoGraph` | `[]`, `set_edge`, `set_edge_inverse`, `num_nodes`, `empty?`, `free_memory`, `print_debugging` |
| `TimeSeriesData` | `Q₁`, `Q₃`, `IQR`, `outliers_lower`, `outliers_upper`, `boundary_outliers_min`, `boundary_outliers_max`, `sum_squared`, `sum_of_squares`, `sum_weighted`, `mean_weighted`, `mean_geometric`, `nᵗʰ_percent_rank`, `healthy?` |

---

# `v0.0.46`

 * add initial support for `Tropical Algebra`
 * `wip`: track `OpenMP` in same style as w/ `OpenGL` & `OpenCL`
 * ⚠: greatly increase scope of upcoming wide-scale refactors
   > tech-debt will out-pace rate of implementation/testing for at least a few versions, then more effective code clean-up will be enabled and performed

| path added | reference | notes |
| ----: | ---- | ---- |
| `lib/ruuuby/math/physics/physics.rb` | `Math::Physics` | not currently utilized, just file added early |
| `lib/ruuuby/math/physics/wave.rb` | `Math::Physics::Wave` | same as above desc. |
| `lib/ruuuby/math/physics/harmonic_analysis.rb` | `Math::Physics::HarmonicAnalysis` | same as above desc. |
| `lib/ruuuby/math/forex/forex.rb` | `Math::Forex` | same as above desc. |
| `lib/ruuuby/math/forex/currency_matrix.rb` | `Math::Forex::CurrencyMatrix` | `wip` |
| `lib/ruuuby/class/nums/vector.rb` | `Vector` | `Ruby` built-in Class (now loaded in) |
| `lib/ruuuby/class/nums/matrix.rb` | `Matrix` | `Ruby` built-in Class (now loaded in) |
| `lib/ruuuby/math/algebra/tropical.rb` | `Math::Algebra::Tropical` |  |
| `ext/ruby_class_mods/c8_graphs.h` | `PseudoGraph` | same creation style as `ThetaAngle` & `TimeSeriesData` |
| `lib/ruuuby/protocol/unix_socket.rb` | `UNIXSocket` | `Ruby` built-in Class (now loaded in) |
| `help/extensions/c/open_mp.md` |  | |

| for | method(s) added |
| ---: | :--- |
| `Vector` | `∅?` |
| `Matrix` | `▣?`, `∀ₓ↘`, `∀ₓᵢ↘`, `↘_to_a`, `∀ₓᵢⱼ`, `num_rows`, `num_cols` |
| `Math::Forex::CurrencyMatrix` | `η̂!`,`algo_🌴_arbitrage`, `karps_algorithm` |
| `Math::Algebra::Tropical::ContextNumeric` | `⨁`, `⨂` |
| `Math::Algebra::Tropical::ContextMatrix` | `⨁`, `⨁!`, `⨂`, `⨂ⁿ` |

---

# `v0.0.45`

 * apply iterative upgrade to `Ruuuby Engine`
   * **ex:** track `GIT attributes` w/ `💎.engine.api_git`
 * fix various edge-case bugs w/ `ThetaAngle` bitwise flags; apply same design to `TimeSeriesData`; start creation of re-usable base code for `Bitwise Flags` in general
 * `ORM`: apply start of refactors for proper support of `RuuubyChangelog` and other automation-functionality; design still `wip`
   * and thus full `DB TDD` & `documentation` is still withheld
 * **remove:** global{`$PRM_MANY`}, update funcs as needed and slightly increase testing coverage
 * move various math functions to better suited locations; more to be done

| gem updated | version previous | version current |
| ----: | :---: | :---- |
| `bundler` | `2.1.4` | `2.2.0.rc.1` |

| path added | reference | notes |
| ----: | ---- | ---- |
| `lib/ruuuby/class/bitwise_flag.rb` | `Ruuuby::BitwiseFlag` | utility/helper, non-core class |
| `.gitattributes` |  |  |
| `lib/ruuuby/math/geometry/shape/sphere.rb` | `Math::Geometry::Sphere` | not currently utilized, just file added early |

| for | method(s) added |
| ---: | :--- |
| `ApplicationRecord` | `orm_Ⓣ_🐍`, `empty?` |
| `Ruuuby::MetaData::RuuubyEngine` | `num_cpu_cores`, `current_user`, `get_compiled_code` |
| `💎.engine.api_git` | `validate_attribute` |
| `Math::Stats::Descriptive` | `percentage_error` |
| `TimeSeriesData` | `ρ`, `flags`, `mape`, `normalize!`, `print_debugging`, `first`, `last`, `λ`, `Λ`, `has_zero?`, `has_negative?`, `normalized?`, `even?`, `strictly_increasing?`, `strictly_decreasing?`, `all_same?` |

---

# `v0.0.44`

 * enable `non-core feature code` to be included/excluded during `pre-processing` as opposed to during `start-up` and/or `runtime`
 * (`wip`) track `OpenCL` & `OpenGL` through `locale RSpecs` (and eventually the `'Ruuuby Engine'`)
 * update gem(`rugged`) version from{`1.0.0`} to{`1.0.1`}
 * update gem(`rspec-benchmark`) version from{`0.5.1`} to{`0.6.0`}
 * add majority of needed initial `ThetaAngle` syntax parsing content; remaining is pending implementation of new functionality/refactors for `ThetaAngle`
 * (`wip`) create class{`TimeSeriesData`}, in similair fashion as `ThetaAngle` (`Ruby object` wrapper over a `C struct instance`)
 * increase and track various default-values for `Ruby Garbage Collector configs`
   * `TimeSeriesData` will eventually be able to be used for discovering optimal `GC-settings`
   * ex: finding optimal `heap-size` and `garbage-collection-frequency` depending on context of script

| path added | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/math/stats/time_series_data.rb` | `TimeSeriesData` | |
| `ext/ruby_class_mods/c7_times_series_data.rb` | `TimeSeriesData` | |
| `lib/ruuuby/ruuuby/engine/ruuuby_api_component.rb` |  | |
| `bin/compilation_modes/build_w_debugging` |  | |
| `bin/compilation_modes/build_simple` |  | |

| for | method(s) added |
| --- | --- |
| `Ruuuby::MetaData::RuuubyEngine::F22B00` | `percentage_protected_from_minor_marks`, `percentage_fragmentation`, `stats_bytes_per_object_slot`, `stats_slots_per_heap_page`, `perform_quick`, `perform_full` |
| (Refinement) `String` | `ʳ?`, `ʳ`, `ᵍ?`, `ᵍ`, `𝞽?`, `𝞽` |
| `TimeSeriesData` | `mem_size`, `free_memory`, `len`, `mean`, `sum`, `max`, `min`, `median`, `range`, `σ²`=>`variance`, `σ`=>`std_dev`, `percentile`, `mse` |

---

# `v0.0.43`
 * add normalizer{`∈𝕌`} for funcs{`flt?`, `🛑flt❓`}
 * start adding textual parsing for `ThetaAngle` via `Refinement` in{`ThetaAngle::ContextStrParsing`}
 * increase scope tested in some db_audit funcs

| path added | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/math/geometry/theta_angle/context_str.rb` | `ThetaAngle::ContextStrParsing` | Refinements onto `String` for parsing to and from `ThetaAngle` |
| `lib/ruuuby/ruuuby/engine/ruuuby_engine_component.rb` | `Ruuuby::MetaData::RuuubyEngineComponent` | start of cleaner design w/ `RuuubyEngine` and relating objs |
| `lib/ruuuby/ruuuby/api/api_locale.rb` | `Ruuuby::MetaData::LocaleAPI` |  |
| `bin/manually_execute/clean_up` |  | delete any temporary/generated content, quick way to force a full re-compile |

| for | method(s) added |
| --- | --- |
| `Math::Stats::TimeSeries` | `aroon_up`, `aroon_down`, `aroon_oscillator`, `simple_moving_average` |
| `Math::Combinatorics::𝕎¹` | `len_powerset` |
| `Math::Combinatorics::𝕎²` | `len_ordered_with_replacement` |
| (`Refinement`) `String` | `°?`, `°` |

---

# `v0.0.42`
 * change normalizer from{!∅} to{∉∅}; add{f06_b03} to provide this normalizer for funcs{ary?, 🛑ary❓}
 * provide function aliases{`wma`, `ema`} to `Math::Stats::TimeSeries`

| for | method(s) added |
| --- | --- |
| `ThetaAngle` | `octant?` |
| `Math::Stats` | `median` |
| `Math::Stats::TimeSeries` | `weighted_moving_average` |

---

# `v0.0.41`
 * iterative upgrade for `💎.engine`'s `JIT`, `CLI`, and `logging`
   * (further track stats like memory, cpu, and other OS specifics)
 * apply clean-ups to{`ThetaAngle`}
   * (increased bitwise-flags utilization, misc bug-fixes, field{repr} represented w/ FIXNUM instead of Symbol, etc)
 * where possible, apply cleaner `OOP`, remove many `Ruuuby` functions and/or data
   * ex: remove various `Singletons & globals`
 * (wip) create logical-divisions within the `RSpec` categories, significantly enabling more `lazy-loading`
   * faster start-up time esp. for targeted scripts
   * ex: compare `rspec_locale{0.04s}` vs `rspec_locale_full{1.33s}`

| path added | reference | notes |
| ---: | --- | --- |
| `ext/ruby_class_mods/c5_internal_structs.h` |  |  |
| `ext/ruby_class_mods/c6_feature_macros.h` |  |  |
| `lib/ruuuby/math/stats/stats.rb` | `Math::Stats` | |
| `lib/ruuuby/math/stats/time_series.rb` | `Math::Stats::TimeSeries` | |
| `lib/ruuuby/math/geometry/shape/shape.rb` | `Math::Geometry::Shape` | not currently utilized, just file added early |
| `lib/ruuuby/math/geometry/shape/plane_figure.rb` | `Math::Geometry::PlaneFigure` | same as ↑ |
| `lib/ruuuby/math/geometry/shape/quadrilateral.rb` | `Math::Geometry::Triangle` | same as ↑ |
| `lib/ruuuby/math/geometry/shape/shape.rb` | `Math::Geometry::Quadrilateral` | same as ↑ |
| `db/db_schema.rb` |  |  |
| `lib/ruuuby/ruuuby/api/abstract_space.rb` |  | not currently utilized, just file added early |
| `lib/ruuuby/ruuuby/api/api_brew.rb` |  | same as ↑ |
| `lib/ruuuby/ruuuby/api/api_docker.rb` |  | same as ↑ |

| for | method(s) added |
| --- | --- |
| `String` | `palindrome?` |
| `ApplicationRecord` | `num_where` |
| `GitCommit` | `num_release_tags` |
| `RuuubyRelease` | `num_released` |
| `Ruuuby::MetaData::RuuubyEngine` | `memory_peak_this_runtime` |
| `Math::NumberTheory` | `semiprime?` |
| `Math::Combinatorics` | `permutations` |
| `Math::Stats` | `arithmetic_mean` |
| `Math::Stats::TimeSeries` | `exponential_moving_average` |

---

# `v0.0.40`
 * track `Just-In-Time Compiler` feature through `locale RSpecs` (and eventually the `'Ruuuby Engine'`)
 * add first usage of Ruby `Refinements` w/ `using Math::NumberTheory::ℤ³` for func{`≡`} w/ Class{`Integer`}
 * move func{`gcd`} to `Math::NumberTheory::ℤ²`, core-implementation moved to `C-ext`
 * start adding content for `ORMs:` {`RuuubyDir`, `RuuubyFile`}
 * start preparing extension code for large scale refactorings to `ThetaAngle`; (also remove func{`to_a`}, no use-case identified)
 * switch `Ruuuby Engine Logging` to utilize the same loading & setup w/ `environment variables` as `ORM-Features` do
 * add/track `gem 'rubygems-update', '~> 3.1.4'`
   * update version from{`3.1.2`} to{`3.1.4`}

| for | method(s) added |
| --- | --- |
| `Symbol` | `as_source_ruby` |
| `ENV` | `parse_feature_behaviors`, `validate_feature_behavior_syntax!` |
| `RuuubyGem` | `fetch_by_type` |
| `Math::NumberTheory::ℤ²` | `fast_gcd` |
| `Math::NumberTheory::ℤ³` | `congruent?` |
| (Refinement) `Integer` | `≡` |

---

# `v0.0.39`
 * update to Ruby version{`2.7.1`} from{`2.7.0`}
 * update gem(`activerecord`) version from{`<IP_ADDRESS>`} to{`<IP_ADDRESS>`}
 * add `RSpec` sections: `integration` & `tech_debt`
 * add the following `Sequence` objs to `Math::NumberTheory::𝕎¹`: `seq_pronic`, `seq_square`, `seq_fibonacci`, `seq_lucas`, `seq_triangle`, `seq_hexagonal`
 * remove some non-ASCII characters in `.h` and `.c` files while testing between compilers `clang` & `gcc`
 * fix typo for const{ANGLE_TAU}, it is now correctly referenced by{`𝞽`} and not{`τ`}
 * various edge-case bugs w/ `ThetaAngle` identified, some are fixed for this version

| path added | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/math/expr/seq/arithmetic.rb` | `Math::Expr::ArithmeticSequence` | (`Ruby` version{`2.7.1`} just added `Enumerator::ArithmeticSequence` which will be looked at prior to further modifications & clean-up of these `Sequence` classes) |
| `lib/ruuuby/math/expr/seq/geometric.rb` | `Math::Expr::GeometricSequence` |  |
| `lib/ruuuby/math/expr/seq/recursive.rb` | `Math::Expr::RecursiveSequence` |  |

| for | method(s) added |
| --- | --- |
| `Math::NumberTheory` | `digit_sum`, `digital_root`, `additive_persistence`, `almost_perfect?`, `nᵗʰ_cototient`, `nᵗʰ_euler_totient`, `friendly?` |
| `Math::Combinatorics` | `n_choose_k` |

---

# `v0.0.38`
 * replace all usages of c-ext-func{`rb_eval_string`} and others that were significantly slowing down `startup/initial-load time`
 * remove funcs{`class?`, `module?`, `singleton?`} from Class(`Object`); (functionality covered by `🧬`)
 * remove func{`𝔠`} from `Kernel` (and thus remove `functional-style` support from previously{`f05`})
 * track `git tags` w/ related `ORMs` & `APIs`; however, version automation tasks paused until `TDD` catches up for `DB` and/or some event/queue-based logic is added (ex: `RabbitMQ`)
 * apply various misc cleanups w/ others `wip`

| path added | reference | notes |
| ---: | --- | --- |
| `lib/math/statistics/statistical_learning.rb` | `Math::Stats::StatisticalLearning` | not currently in use |
| `lib/math/statistics/probability_theory.rb` | `Math::Stats::ProbabilityTheory` | not currently in use |
| `lib/math/statistics/descriptive_statistics.rb` | `Math::Stats::DescriptiveStatistics` | not currently in use |
| `lib/math/combinatorics/combinatorics.rb` | `Math::Stats` | not currently in use |

| for | method(s) added |
| --- | --- |
| `Math::Space::NucleotideSpace` | `∋ˢ?` |
| `Ruuuby::MetaData::GitAPI` | `release_tags`, `branch_names`, `remote_release_current`, `remote_release_previous` |
| `Math::NumberTheory` | `aliquot_sum`, `deficient?`, `deficiency`, `abundant?`, `abundance`, `abundancy_index`, `composite?` |

---

# `v0.0.37`
 * have `ORM`: `RuuubyRelease` and `GitCommit` include `Comparable`; replacing redundant funcs{`>`, `<`} to the single func{`<=>`}
 * remove `♾`, `¿` from all sources, textual parsing, code aliases, etc; (too redundant)
 * remove func{∞?} from Class(`String`)
 * add `ORM`{`RuuubyGem`}, some functionality was added; also removed runtime constants needed solely for unit-tests (these tests are now semi-generated w/ `ORM` data)
 * add `RSpec` section for `locale` (local configs); `(not final design)`

| path added | reference | notes |
| ---: | --- | --- |
| `lib/virtual/f06.rb` |  |  |
| `app/models/ruuuby_gem.rb` | `RuuubyGem` |  |
| `lib/virtual/f28.rb` |  |  |
| `lib/math/complex_analysis/complex_analysis.rb` | `Math::ComplexAnalysis` | |
| `lib/math/trigonometry/trigonometry.rb` | `Math::Trigonometry` | |
| `lib/math/graph_theory/graph_theory.rb` | `Math::GraphTheory` | |
| `lib/math/geometry/geometry.rb` | `Math::Geometry` | | |
| `lib/math/space/discrete/symbolic_numbers_space.rb` | `Math::Space::SymbolicNumbersSpace` | 𝕊 |

| for | method(s) added |
| --- | --- |
| `Object` | `ⓣ`, `Ⓣ` |

---

# `v0.0.36`
 * remove func{`get_prime_factors`} from `Integer`, newly created module{`Math::NumberTheory`} now offers that functionality
 * local git-config settings are now enforced with newly created `💎.api_git`, version-automation refactorings started

| path added | reference | notes |
| ---: | --- | --- |
| `lib/math/expression/equation.rb` | `Math::Expression::Equation` | |
| `lib/math/expression/sequence.rb` | `Math::Expression::Sequence` | |
| `lib/math/group_theory/circle_group.rb` | `Math::GroupTheory::CircleGroup` | aliased via(`𝕋`) |
| `lib/ruuuby/ruuuby/git_api.rb` | `Ruuuby::MetaData::GitAPI` | `💎.api_git` (to fully replace existing `git` functionality found in `💎.api` and elsewhere) |
| `lib/math/number_theory/number_theory.rb` | `Math::Ruuuby::NumberTheory` |  |

| for | class-method(s) added |
| --- | --- |
| `Math::NumberTheory::ℕ¹` | `get_prime_factors`, `get_divisors`, `get_proper_divisors`, `perfect_number?` |
| `Math::NumberTheory::ℕ²` | `gcd`, `coprime?` |

---

# `v0.0.35`
 * add `gem 'rugged', '~> 1.0.0'`
 * apply general clean-ups, next few versions to have similar target
 * remove many function calls and variables that didn't need to be executed or exist; start adding extra checks via{`mkmf`} which will halt/fail even before the compilations step
 * remove alias `🧬?`, `🧬` is now a 'global-alias' for the singleton{`NucleotideLikeSpace`}
 * remove alias `🅱?`, `🛑🅱❓`, etc; just `🅱` is now a 'global-alias' for the single{`BooleanLikeSpace`}
 * remove funcs{`stry?`, `countable?`} and{`🛑stry❓`, `🛑countable❓`}
 * remove `::Ruuuby::VirtualTypes` and it's file
 * remove funcs{`∃class?`, `∃module?`} from `Kernel`, functionality is now covered by singleton{`NucleotideLikeSpace`} which is aliased via{`🧬`}
 * remove various redundant emoji aliases as the added feature{`f97`}, will enable selected character sets without the clutter of unwanted characters and aliases
 * add more detail to various `ORM` features/funcs, documentation and TDD still intentionally not fully present for these
 * add class `DescriptiveStandardError`

| path added | reference | notes |
| ---: | --- | --- |
| `lib/math/expression/expression.rb` |  | |
| `lib/math/expression/formula.rb` |  |  |
| `lib/math/space/tuple_space.rb` |  |  |
| `lib/math/space/types_space.rb` |  |  |
| `lib/math/space/discrete/boolean-like_space.rb` | ``Math::Space::BooleanLikeSpace`` |  |
| `lib/math/space/discrete/number-like_space.rb` | ``Math::Space::NumberLikeSpace`` |  |
| `lib/math/space/discrete/nucleotide-like_space.rb` | ``Math::Space::NucleotideLikeSpace`` |  |

| for | method(s) added |
| --- | --- |
| `TrueClass`, `FalseClass` | `to_i`, `to_b` |
| `Rational` | `μ?` |
| `String` | `to_🐫⬇`, `to_🐍⬆` |

# `v0.0.34`
 * increase precision of various funcs (ex: `sin²` and `cos²`), by performing calculations in `long double` instead of `double`
 * add `𝞽` as a 'global-const' which is a ThetaAngle representing a single complete turn
 * adjust parameter style of class-functions for `Math` to use named params
 * remove global-alias-funcs{`ℂ`, `ℚ`}; these now correspond to a specific singleton instance of the newly created class(`Math::SetTheory::NumberSet`)
 * add `super golden ratio` as `Ψ`, `silver ratio` as `δ`, `plastic ratio` as `ρ`, `omega constant` as `Ω`
 * remove various out-dated testing helper functions, meta-data generation/processing will eventually replace this
 * remove `Array::EMPTY_INSTANCE`, `∅` by itself now aliases a singleton of type{`NumberSet`}
 * create `ORM`{`RuuubyFeatureBehavior`} which is many to one{`RuuubyFeature`}
 * remove number-set membership check funcs from `Numerics` and create `singleton` instances of `NumberSet` which covers the previous functionality (just more scalable)
 * remove as much deprecated code as possible, file structure adjustments started
 * move `Float`'s method{`≈≈`} into `C-extensions`
 * remove funcs (and related ones): `🛑ℤ❓` and `🛑𝕌❓`, these checks are now covered by existing functions w/ new types of normalizers added for existing normalizer feature

| path added | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/math/set_theory/closure.rb` | ``Math::SetTheory::Closure`` |  |
| `lib/ruuuby/math/set_theory/number_set.rb` | ``Math::SetTheory::NumberSet`` |  |
| `lib/ruuuby/math/set_theory/discrete/algebraic_numbers.rb` | ``Math::SetTheory::AlgebraicNumbers`` |  |
| `lib/ruuuby/math/set_theory/discrete/boolean_numbers.rb` | ``Math::SetTheory::BooleanNumbers`` |  |
| `lib/ruuuby/math/set_theory/discrete/complex_numbers.rb` | ``Math::SetTheory::ComplexNumbers`` |  |
| `lib/ruuuby/math/set_theory/discrete/empty_set.rb` | ``Math::SetTheory::EmptySet`` |  |
| `lib/ruuuby/math/set_theory/discrete/imaginary_numbers.rb` | ``Math::SetTheory::ImaginaryNumbers`` |  |
| `lib/ruuuby/math/set_theory/discrete/integer_numbers.rb` | ``Math::SetTheory::IntegerNumbers`` |  |
| `lib/ruuuby/math/set_theory/discrete/irrational_numbers.rb` | ``Math::SetTheory::IrrationalNumbers`` |  |
| `lib/ruuuby/math/set_theory/discrete/natural_numbers.rb` | ``Math::SetTheory::NaturalNumbers`` |  |
| `lib/ruuuby/math/set_theory/discrete/null_set.rb` | ``Math::SetTheory::NullSet`` |  |
| `lib/ruuuby/math/set_theory/discrete/rational_numbers.rb` | ``Math::SetTheory::RationalNumbers`` |  |
| `lib/ruuuby/math/set_theory/discrete/real_algebraic_numbers.rb` | ``Math::SetTheory::RealAlgebraicNumbers`` |  |
| `lib/ruuuby/math/set_theory/discrete/real_numbers.rb` | ``Math::SetTheory::RealNumbers`` |  |
| `lib/ruuuby/math/set_theory/discrete/universal_set.rb` | ``Math::SetTheory::UniversalSet`` |  |
| `lib/ruuuby/math/set_theory/discrete/whole_numbers.rb` | ``Math::SetTheory::WholeNumbers`` |  |
| `app/models/ruuuby_feature_behavior.rb` |  |  |
| `ext/ruby_class_mods/c4_theta_angle.h` |  | for organization |

| for | method(s) added |
| --- | --- |
| `Object` | `set?`, `🛑set❓` |
| `Integer` | `get_prime_factors` |
| `ThetaAngle` | `normalize`, `windings` |

---

# `v0.0.33`
 * create new Class(`ThetaAngle`) which is essentially a wrapper over a `C-struct`
 * modify global-funcs `sin`, `cos`, `tan`, etc to utilize the `ThetaAngle` class
 * add empty code file(`lib/ruuuby/class/method/math_function.rb`) for future versions
 * apply lots of misc clean-ups and/or adjustments
 * `v0.0.34` to resolve missing parts from `ThetaAngle` and clean-up relating funcs from `String`

| path added | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/class/nums/theta_angle.rb` | `ThetaAngle` |  |

| for | method(s) added |
| --- | --- |
| `Object` | `θ?`, `🛑θ❓`, `enumerable?`, `🛑enumerable❓` |
| `Math` | `pythagoras_τ³?`, `cot`, `csc`, `sec`, `sin²`, `cos²` |
| `TOPLEVEL_BINDING` | `℮`, `logₑ`, `log₂`, `log₁₀`, `arcsin`, `arccos`, `arctan`, `cot`, `csc`, `sec`, `sin²`, `cos²` |
| `TOPLEVEL_BINDING` | `⅓`, `⅕`, `⅕`,`⅖`,`⅗`,`⅘`,`⅙`,`⅐`, `⅛`, `⅜`, `⅝`, `⅞`, `⅑`, `⅒` |
| `TOPLEVEL_BINDING` | `θ°`, `θʳ`, `θᵍ`, `θ𝞽` |
| `ThetaAngle` | `real`, `repr`, `as_radian`, `as_degree`, `as_gon`, `as_turn`, `radians?`, `degrees?`, `gons?`, `turns?`, `-@`, `+@`, `coerce`, `~`, `!`, `+`, `-`, `*`, `%`,`==`, `/`, `<=>`, `angle?`, `normal?`, `normalize!`, `golden_with?`, `explementary_with?`, `supplementary_with?`, `complementary_with?`, |

| from       | methods/aliases removed |
| ---------- | ----------------------- |
| `Kernel`   | `∠ᶜ`, `∠°` |

---

# `v0.0.32`
 * add flags to the compilation and linker steps (`wip`); replace locations in `C-extensions` that were previously accessing pointers not intended to be used beyond its internal scope (internal to `Ruby`)
 * global-func(`φ`) removed, reference replaced with(`𝚽`), a `Kernel` constant; also add the golden-angle constant(`Ⴔ`)
 * start utilizing more generic math notation where possible, ex-func(`∀τ²∈λ𝑓₍ᵢ،ᵢ₊₁₎`), very useful as this automatically applies (for example) to both regular objects like `Array` and also `ORM` objects like `RuuubyRelease` while still applicable to both
 * `v0.0.33` to utilize `golden-angle` as well as dramatically alter angle-trig related functions

| path added | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/module/attribute/includable/singleton.rb` | `Ruuuby::Attribute::Includable::RuuubySingleton` |  |
| `lib/ruuuby/module/attribute/extendable/singleton.rb` | `Ruuuby::Attribute::Extendable::RuuubySingleton` |  |
| `lib/ruuuby/class/proc.rb` | ``Proc`` |  |

| for | method(s) added |
| --- | --- |
| `Enumerable` | `∀τ²∈λ𝑓₍ᵢ،ᵢ₊₁₎` |

---

# `v0.0.31`
 * remove constants needed previous for supporting exponential operations from m(`Numeric`), needed values are now dynamically generated by `C-extensions` instead of relying on pre-existing constants (created specifically for just this purpose)
 * lots of misc edits/clean-ups in `C-extensions`
 * remove various un-used or now deprecated Modules such as `Ruuuby::MetaData::Vocabulary` (was a temporary location for `normalizers`)
 * engine/configs cleaned up and support started for multi-flag ENV_VARs
 * automation for `db/seeds/git_commits.rb` updated to better handle scenario where release had multiple commits, still lots of TODOs and missing `TDD` to be added
 * various modifications & additions to existing `ORM` Classes for general stability/reliability
 * flipped functionality of String's funcs `to_iso8601` and `as_iso8601` to closer match `Ruby style`

| path added | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/virtual/env` | ``ENV`` | note: `class << ENV` |
| `db/seeds/ruuuby_releases/future_ruuuby_releases.rb` |  | not currently used |

| for | method(s) added |
| --- | --- |
| `String` | `as_utf8` |
| TOPLEVEL_BINDING | `¼`, `½`, `¾`, `🌽` |
| `File` | `insert_lines_before_expr` |
| `GitCommit` | `get_latest`, `query_get_newest_within_version` |
| `RuuubyRelease` | `on_before_save` |

| from | methods/aliases *removed* |
| ------------------- | --------------------- |
| `Symbol`   | `power?`, `pow_to_i` |

---

# `v0.0.30`
 * add normalizers to `sym?`
 * continued ORM cleanups started in `v0.0.29`
 * iterative step in enabling textual parsing for more useful code-file automations

| path added | reference | notes |
| ---: | --- | --- |
| `app/model_attributes/extendable/uid.rb` | |
| `app/model_attributes/includable/uid.rb` | |

| for | method(s) added | notes |
| --- | --- | --- |
| `Object` | `singleton?` | |
| `Object` | `🅱?`, `🛑🅱❓`, `🧬?` | |
| `Module` | `get_all_defined_modules`, `get_all_defined_classes` | |
| `String` | `iso8601?`, `to_iso8601`, `as_iso8601` | |

---

# `v0.0.29`
 * misc cleanup for `ORM`, example: remove un-needed m(`ApplicationRecord::ORMAttributeCache`)
 * general cleanup for `QA`/`RSpecs`, especially w/ file loading order
 * add initial start of `ORM` schemas `RuuubyFiles` and `RuuubyDirs`
 * general functionality increases for `Ruuuby` `MetaData`, add global func `💎` for quicker reference
 * add logger with output in directory{`tmp`}, file{`ruuuby.log`}

| path added | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/ruuuby/engine/ruuuby_engine.rb` | `Ruuuby::MetaData::RuuubyEngine` | alias{`💎.engine`} |
| `lib/ruuuby/ruuuby/engine/ruuuby_logging.rb` | `Ruuuby::MetaData::RuuubyEngine.instance.logger` | alias{`💎.engine.logger`} |
| `lib/ruuuby/ruuuby/metadata/ruuuby_metadata_constants.rb` | ``Ruuuby::MetaData`` |  |
| `app/models/ruuuby_dir` | ``RuuubyDir`` | directory operations specifically for `ORM` related context/use-cases |
| `app/models/ruuuby_file` | ``RuuubyFile`` | file operations specifically for `ORM` related context/use-cases |

| for | method(s) added | notes |
| --- | --- | --- |
| `Array` | `∅` | starting point of adding similar immutable references like `nil` but for (assumable to be immutable) objects that are `∅` |
| `Object` | `🛑sym❓` | |
| `Ruuuby::MetaData` | `orm`, `orm_meta`, `paths`, `engine` | shortcuts to either modules or singleton-instanced objects |
| `Ruuuby::MetaData` | `info`, `debug` | shortcuts for logging statements |
| TOPLEVEL_BINDING | `ℂ`, `ℚ` | alias to `Complex`
alias to `Rational` |
| `Kernel` | `💎`  | alias to `Ruuuby::MetaData` | |
| `File` | `insert_line_before_expr` | |

---

# `v0.0.28`
 * updating contents of `db/seeds/git_commits.rb` is now automated (starting point, LOTs of TODOs to guard against any edge case scenarios and future functionality requirements)
 * move funcs `class?`, `module?`, `nucleotide?` into `C-extensions` (also add `char?`)
 * iterative step in enabling textual parsing for more useful code-file automations
 * add normalizers to funcs `int?` and `str?`, allows (mainly-visual) clean-up for `Ruuuby` funcs `🛑str❓` and `🛑int❓`
 * add types to `Ruuuby::VirtualTypes`
 * rename c(`String`)'s func{♻until!} to {remove_until}, add alias(`♻⟶`); also add reverse direction w/ func{`♻⟵`}

| path added | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/ruuuby/ruuuby_orm.rb` | `Ruuuby::MetaData::RuuubyORM` |  |
| `lib/ruuuby/ruuuby/routine_cli.rb` | `Ruuuby::Routine::CommandCLI` |  |

| for | method(s) added |
| --- | --- |
| `String` | `char?`,  |
| `String` | `♻⟵`, `♻⟶∞`
 [`upcase?`, `⬆?`, `⬆?`, `🔠?`]
 [`downcase?`, `⬇?`, `⬇?`, `🔡?`] |
| `String` | `🐫?`, [`🐫⬇?`, `🐫⬇?`, `🐫🔡?`], `to_🐫`
 `🐍?`, [`🐍⬆?`, `🐍⬆?`, `🐍🔠?`], `to_🐍` |

---

# `v0.0.27`
 * contents in `db/seed.rb` split across files in newly created dir: `db/seeds/`; also add new `ORM: GitCommit`, (one `RuuubyRelease` to many `GitCommits`)
 * performing update of version number for `README.md` and `lib/ruuuby/version.rb` is now automated
 * m{`Module`}'s func{`⨍_add_aliases`} converted to alias the func{`f_add_aliases`} created from `C-extensions`

| gem added | version |
| ---: | :---- |
| `schema_plus_foreign_keys` | `0.1.8` |

| path added | reference | notes |
| ---: | --- | --- |
| `db/seeds/git_commits.rb` |  |  |
| `db/seeds/ruuuby_features.rb` |  |  |
| `db/seeds/ruuuby_releases.rb` |  |  |
| `app/models/git_commit.rb` | `::GitCommit` |  |
| `lib/ruuuby/ruuuby/ruuuby_api.rb` | `::Ruuuby::RuuubyAPI` |  |
| `lib/ruuuby/ruuuby/routine.rb` |  | `example usage: Routine::CMD.new` |

| for | method(s) added |
| --- | --- |
| `File` | `dirname⁴` |

---

# `v0.0.26`
 * cleanup creation of function aliases (remove redundant declarations, move needed ones into `ide_helper`, and use new func{`⨍_add_aliases`} where possible)
 * `DRY`: attribute-module(`Cardinality`) now auto-assigns the alias `𝔠`
 * reduce number of locations requiring manual edits/checks when releasing version updates
 * add normalizer_option(`:ℕ`) to func(🛑int❓)
 * add `RSpec` section `db`, clean-up various locations where `db/seed` was loaded before

| added path | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/module/attribute/includable/notation_set_mathematics.rb` | `Ruuuby::Attribute::Includable::Notation::SetMathematics` |  |
| `lib/ruuuby/ruuuby/ruuuby_metadata.rb` | `Ruuuby::MetaData` | design pending |

| class | method(s) added |
| --- | --- |
| `Module` | `⨍_add_aliases` |
| `File` | `replace_expr_with`, `replace_expr_with!` |
| `RuuubyRelease` | `<`, `>`, `get_next_version_uid`, `get_latest_version_uid` |

| class | alias(es) added |
| --- | --- |
| `Object` | (freeze) `❄`, `❄?` |

---

# `v0.0.25`
 * start dividing `C-code` across multiple header files, lots of small misc changes (ex: moved various constants definitions from `Ruuuby's` `Float`)
 * re-structure `Feature` <---> `Module` mapping, add `audit` tests to verify pattern is present/consistent
 * move certain funcs out of `Kernel` and directly add them to `TOPLEVEL_BINDING` to avoid polluting other classes
 * start formalization of existing funcs w/ name(`η̂`, `normalize`) and/or when `normalization` is applied to `args` (any context)
 * symbolic-math support being added only for niche use-cases, `automatic-differentiation` features to take priority in case of any feature-conflicts

| added path | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/global_funcs.rb` |  |  |
| `ext/ruby/class_mods/c0_constants.h` |  |  |
| `ext/ruby/class_mods/c1_typed_checks.h` |  |  |
| `ext/ruby/class_mods/c2_extension_memory.h` |  |  |
| `ext/ruby/class_mods/c3_macro_utilities.h` |  |  |

| for | method(s) added |
| --- | --- |
| `String` | `♻until!` |
| `TOPLEVEL_BINDING` | `tan`, `tan°` |
| `String` | `to_radian` |

| for | alias(es) added |
| --- | --- |
| `Array` | (remove_empty!): `♻∅!` |
| `Set` | (remove_empty!): `♻∅!` |
| `String` | (reverse): `↩`, `↩!`, `↩`, `↩!` |
| `Array` | (reverse): `↩`, `↩!`, `↩∀` |

---

# `v0.0.24`
 * ensure `Ruby` data created from `C-extensions` gets guarded against `garbage-collection`
 * start utilizing configs for `Ruuuby`, especially for debugging information

| added path | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/configs.rb` |  |  |

---

# `v0.0.23`
 * (starting-point) add support for representing `Complex Infinity`; (for now) via Symbol(`∞ℂ`)
 * add Attribute(`SubscriptIndexing`) to Class(`Symbol`)
 * add missing tests and fix bugs (missing scenario coverage) for c(`Object`)'s funcs `🛑ℤ❓` and `🛑𝕌❓`
 * `power-operations` given support for working with 'custom' `infinitity values`, Class(`Rational`) given support for `superscript-power-operations`

| for | method(s) added |
| --- | --- |
| `Kernel` | `¿`, `∞`, `∞ℂ` |
| `Integer` | `¿?`, `nan?`, `∞ℂ?` |
| `Float` | `¿?`, `∞ℂ?` |
| `Symbol` | `power?`, `pow_to_i` |
| `Rational` | `^` |

---

# `v0.0.22`
 * continued (minor) improvements to catching bad parameters & throwing needed errors
 * add func(`err_to_num`) to class(`String`) as a utility function for throwing errors
 * start organizing groups of functions into modules labeled by their `Feature` or `Attribute` (`includable` or `extendable`)
 * tech debt accumulation to be dealt with by `v0.1.0` to remove all `🍝 code` prior to adding support to `automatic differentiation`

| added path | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/class/sym.rb` | `Symbol` |  |
| `lib/ruuuby/module/attribute/includable/cardinality.rb` | `Ruuuby::Attribute::Includable::Cardinality` |  |
| `lib/ruuuby/module/attribute/includable/subscript_indexing.rb` | `Ruuuby::Attribute::Includable::SubscriptIndexing` |  |
| `lib/ruuuby/module/attribute/includable/syntax_cache.rb` | `Ruuuby::Attribute::Includable::SyntaxCache` |  |
| `lib/ruuuby/module/attribute/extendable/syntax_cache.rb` | `Ruuuby::Attribute::Extendable::SyntaxCache` |  |

| for | method(s) added |
| --- | --- |
| `Object` | `🛑𝕌❓` |
| `Array` | `η̂!` |
| `Symbol` | (downcase, upcase) `⬇`, `⬇`, `🔡`, `⬆`, `⬆`, `🔠` |
| `String` | (downcase, upcase) `⬇`, `⬇`, `🔡`, `⬆`, `⬆`, `🔠`, `⬇!`, `⬇!`, `🔡!`, `⬆!`, `⬆!`, `🔠!` |
| `Enumerable` | `∀ₓᵢ` (each_with_index) |
| `Object` | `define_singleton_⨍` (define_singleton_function) |
| `Kernel` | `🌽_previous_⨍` |
| `String` | `digit?`, `to_num`, `to_num?` |

---

# `v0.0.21`
 * add const `NUCLEOTIDES` to `Ruuuby::VirtualTypes`
 * add missing scenarios & tests for `spec/helpers/static_test_data.rb`
 * add `global-constant`(`$PRM_MANY`), param-type checking functions expanded for multi-param check use-cases
 * add modules `ORMAttributeUID` and `ORMAttributeCache` to `ApplicationRecord` as well as module(`Syntax`), which each `ORM Class` will also define

| added path | reference | notes |
| ---: | --- | --- |
| `bin/console_db` |  | same as `/bin/console` but also pre-loads `db/seed.rb` |
| `lib/ruuuby/class/re.rb` | `Regexp` |  |
| `app/models/db_schema.rb` | `RuuubyDBSchema` | `temporary design` |
| `lib/ruuuby/module/attribute_extendable/static_attribute_syntax_cache` | `Ruuuby::StaticAttributeSyntaxCache` | |

| for | method(s) added |
| --- | --- |
| `Object` | `class?`, `module?`, `nucleotide?` |
| `Module` | `∋?`, `∌?`, `∈?`, `∉?` |
| `Object` | `🛑ℤ❓` |

---

# `v0.0.20`
 * add consts `RATIO_DEGREES_TO_RADIAN` and `RATIO_RADIANS_TO_DEGREE` into module `Math`
 * power-operations for `Integer` and `Float` given support for raising from `-1` to `-9` via superscripts(`⁻¹` to `⁻⁹`)

| added path | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/module/math.rb` | ``Math`` |  |
| `help/math/automatic_differentiation.rb` |  | `Ruuuby's` current main focus to add functionality support to |

| for | method(s) added |
| --- | --- | --- |
| `Object` | `🛑flt❓` |
| `Float` | `≈≈` |
| `Kernel` | `sin` |
| `Kernel` | `sin°` |
| `Kernel` | `cos` |
| `Kernel` | `cos°` |
| `Kernel` | `∠ᶜ` |
| `Kernel` | `∠°` |

---

# `v0.0.19`
 * add some data-type/db-validation for `ORM`, still lots of TODOs here
 * purge `ruuuby/version.rb` of all content except `constant String`: `VERSION` (as `ORM` functionality will cover prior needed use-cases)
 * add missing test cases for power-operations and `Object's` funcs(`flt?`, `num?`)
 * power-operations for `Float` moved into `ruby_class_mods.c`
 * general improvements for performance-testing and `RSpec` structuring
 * `ruby_class_mods.c` to start using `non-ascii` based `#define` statements
 * start adding code for negative-exponents

| for | method(s) added |
| --- | --- |
| `File`, `Dir` | `∅?` |
| `ApplicationRecord` | `♻`, `♻!` |
| `Kernel` | `🎲`, `∛`, `π`, `φ`, `γ` |
| `Object` | `⁻¹`, `⁻²`, `⁻³`, `⁻⁴`, `⁻⁵`, `⁻⁶`, `⁻⁷`, `⁻⁸`, `⁻⁹` |
| `Dir` | `normalized_paths` |

---

# `v0.0.18`
 * renaming existing func(`🛑str_or_ary❓`) to(`🛑countable❓`); it now checks for `Set` as well
 * add `gem 'sqlite3', '~> 1.4.2'`
 * add `gem 'activerecord', '~> <IP_ADDRESS>'`
 * start process of tracking language changes across versions into `ORM`/`db`
   * start process of auto-generating documentation from these objects

| added path | reference | notes |
| ---: | --- | --- |
| `lib/ruuuby/class/io/file.rb` | `File` |  |
| `lib/ruuuby/class/io/dir.rb` | `Dir` |  |
| `lib/ruuuby/types.rb` | `Ruuuby::VirtualTypes` | adds (module-scoped) constants `🅱`, `STRY`, `NUMS`, `COUNTABLES`  |
| `app/models/application_record.rb` | `ApplicationRecord` |  |
| `app/models/ruuuby_changelog.rb` | `RuuubyChangelog` |  |
| `app/models/ruuuby_feature.rb` | `RuuubyFeature` |  |
| `app/models/ruuuby_release.rb` | `RuuubyRelease` |  |
| `lib/ruuuby/class/method.rb` | `Method`` |  |
| `conditionals/ide_helper.rb` |  | received all duplicated aliases (for playing nice with IDEs, happens from funcs created in `C-extension`)  |
| `db/db.rb` |  |  |
| `db/seed.rb` |  |  |

| class(es) | method(s) added |
| --- | --- |
| `File`, `Dir` | `∃?` |
| `File` | `dirname²`, `dirname³` |
| `Kernel` | `📁` (`File`), `📂` (`File`), `🗄` (`Dir`) |
| `Object` | `flt?`, `num?` |
| `Integer`, `Numeric` | `♾?` (infinite?) |
| `Method` | `🏠` (`source_location`) |

---

# `0.0.17`

#### Abstract
 * start general, wide-scale, re-structuring to manage changes into categorized `features`

#### Discrete
 * continued audit on number classes (see notes from v`0.0.15-16`)
 * for math related `RSpecs`, move common/shared `let` definitions into `spec_helper.rb`, add additional ones to form a general schema for testing data

#### Methods & Aliases:
 | for                              | methods/aliases added |
 | -------------------------------- | --------------------- |
 | `Kernel`                         | `𝔠`                   |
 | `String`, `Set`, `Array`, `Hash` | `𝔠` (length)          |
 | `Class`                          | `🆕` (new)            |
 | `Object`                         | `⁰`, `¹`, `²`, `³`, `⁴`, `⁵`, `⁶`, `⁷`, `⁸`, `⁹` |
 | `Object` | `🛡funcs` (protected_methods), `🙈funcs` (private_methods) |
 | `Module` | `🛡` (protected), `∃🛡func?` (protected_method_defined?), `🛡instance_funcs` (protected_instance_methods), `🙈instance_funcs` (private_instance_methods), `🙈class_func` (private_class_method) |
 | `Integer`                        | `^`, `preserved_reference_to_bitwise_or` |
 | `Float`                          | `^` |

#### Files Added:
 * `ruuuby/class/class.rb`

---

# `v0.0.16`
 * modify various functions to not allocate un-necessary memory (ex: call `.reverse_each` instead of `reverse.each`)
 * continued audit on number classes (see notes from v`0.0.15`), add domain checks for `𝕌?`, `𝔹?`
 * add first multi-step audit test against project file structure (will require better solution, just a starting point)
 * add/move the following methods/aliases:

 | for                              | methods/aliases added/moved                               |
 | -------------------------------- | --------------------------------------------------------- |
 | `Array`                          | `equal_contents?` (`≈≈` now aliases it)                   |
 | `Array`                          | `frequency_counts` (`📊` now aliases it)                  |
 | `Array`                          | `disjunctive_union` (`⊕` now aliases it)                  |
 | `Array`                          | `↩` (reverse), `↩!` (reverse!), `↩∀` (reverse_each)   |
 | `Object`                         | `🅱?` (alias to `bool?`), `🛑🅱❓`                       |
 | `Integer`                        | `∞?`, `𝕌?`                                                |
 | `Float`, `Complex`, `BigDecimal` | `𝕌?`                                                      |
 | `Numeric`                        | `𝕌?`, `𝔹?`                                                |
 | `Hash`                           | `🗝?`, `∃🗝?` (both alias `key?`, same as `🔑?`, `∃🔑?`) |

---

# `v0.0.15`
 * add directory `ruuuby/class/enumerable`, move `ary.rb`, `hsh.rb` and newly created `set.rb` into it
 * add files: `ruuuby/module/enumerable.rb` and `ruuuby/class/nums/numeric.rb`
 * move various existing functions/aliases from sub-classes into common parent modules and/or classes where possible, ex: `∌?` out of `Array` and into `enumerable` to share common features w/ others like `Set`
 * move certain module/class initial definition/creation into `ruby_class_mods.c`
 * for number classes (ex: `Integer`), fix various logical/performance/test-coverage flaws for funcs like `ℕ?`

 |  for            | methods/aliases added/moved                      |
 | --------------- | ------------------------------------------------ |
 | `Array`         | `start_with?`, `ensure_start!`                   |
 | `Set`           | `remove_empty!`, `∅?` (empty?), `∀` (each), `∋?` |
 | `Enumerable`    | `∌?`, `⨍` (map)                                  |
 | `Numeric`       | `∞?` (infinite?)                                  |
 | `Integer`       | `finite?`, `infinite?`                             |

---

# `v0.0.14`
 * add gem `'tty-command', '~> 0.9.0'` to group `runtime`
 * for use by `audit RSpecs`: start various means of tracking internal versions, configs, etc; will help form dynamically generated audits and reports
 * temporarily remove `.travis.yml` (auto-generated at project creation but would be useful to utilize)
 * adjust naming on param check functions (in `Ruuuby::ParamErr`), ex: `🛑❓bool` change to `🛑bool❓`

---

# `v0.0.13`
 * move utility functionality from `spec_helper.rb` and others into newly created Directory: `spec/helpers/`
 * remove param:`use_partial_fill_in` from `String`'s funcs `ensure_start!` and `ensure_ending!`
 * heavily adjust usage/style for throwing param errors via `Ruuuby::Err` now(`Ruuuby::ParamErr`)
 * add new type of RSpec: `audit`

 | for                  | methods/aliases added |
 | -------------------- | --------------------- |
 | `Hash`               | `∀` (each), `∅?` (empty) |
 | `Kernel`             | `🛑` (raise), `√` (Math.sqrt) |
 | `Module`             | `∃func?` (func created and alias removed), `∃🙈func?` (private_method_defined?) |
 | `NilClass`, `String` | `∅?` (empty) |
 | `Array`              | `ensure_ending!`, `end_with?`, `∅?` (empty), `uniq_to_me` (∖) |
 | `Object`             | `🛑❓bool`, `🛑❓int`, `🛑❓ary`, `🛑❓str`, `🛑❓stry`, `🛑❓str_or_ary` |

* remove the following methods/aliases:

| for             | methods/aliases removed |
| --------------- | --------------------- |
| `Ruuuby::Err`   | `param¬bool`, `param¬str`, `param¬stry`, `param¬ary`, `param¬module`, `param¬class` |

---

# `v0.0.12`
 * organize `ruuuby/version.rb` into major, minor, & tiny versions
 * add string generating macros for `rb_require` in `ruby_class_mods.c`
 * remove certain helper funcs from `spec_helper.rb` as core language adds similar wrappers
 * add organization and new information to `help/ruuuby.md`
 * add files: `ruuuby/module/kernel.rb`, `ruuuby/module/module.rb`, and `ruuuby/arg_err.rb`

 | for                 | methods/aliases added |
 | ------------------- | --------------------- |
 | `Module`        | `🙈`, `🙈constants⟶`, `∃const?`, `∃func?`, `∃func_alias?` |
 | `Kernel`        | `∃module?`, `∃class?` |
 | `Ruuuby::Err`   | `param¬bool`, `param¬str`, `param¬stry`, `param¬ary`, `param¬module`, `param¬class` |
 | `Ruuuby::Err::WrongParamType` | `generate_error_text`, `throw` |
 | `Object`        | `stry?`               |

---

# `v0.0.11`
 * add more organization to `extconf.rb`
 * add `bin/audit_quick` for faster iterative development
 * add missing section in performance testing tiers and general cleanup to some RSpec structure
 * move/add the following to `ruby_class_mods.c`
   * move `Array`'s added method `>>`
   * move `String`'s added method `>>`
   * add private method `disjunctive_union` to `Array` for use in method`⊕`

 | for                 | methods/aliases added |
 | ------------------- | --------------------- |
 | `Hash`              | `🔑?`, `∃🔑?`         |
 | `Array`             | `∀`, `📊`, `≈`        |
 | `Ruuuby`            | `∃module?`, `∃class?` |

---

# `v0.0.10`
 * move various `require` statements from `ruuuby.rb` to `ruby_class_mods.c`
 * remove all `Ruuuby::Enum`'s and relating references
 * add/update minor details to `README.md`
 * add `help/jruby.md` to document jruby extensions gotchas along the way
 * add initial `Dockerfile` and `docker-compose.yml`

 | class        | methods added                |
 | -----------  | ---------------------------- |
 | `Integer`    | `ℕ?`, `ℤ?`, `ℚ?`, `ℂ?`, `ℝ?` |
 | `Float`      | `ℕ?`, `ℤ?`, `ℚ?`, `ℂ?`, `ℝ?` |
 | `BigDecimal` | `ℕ?`, `ℤ?`, `ℚ?`, `ℂ?`, `ℝ?` |
 | `Complex`    | `ℕ?`, `ℤ?`, `ℚ?`, `ℂ?`, `ℝ?` |
 | `Rational`   | `ℕ?`, `ℤ?`, `ℚ?`, `ℂ?`, `ℝ?` |

---

# `v0.0.9`
 * add example usage in `README.md`
 * add various aliases and functions for additional set math operations

 | class    | method(s)/alias(es) added |
 | -------  | ------------------------- |
 | `Array`  | `∌?`, `∋?`                |
 | `String` | `∌?`, `∋?`, `∈?`, `∉?`    |

---

# `v0.0.8`
 * mark various files with `UTF-8` encoding: `# -*- encoding : utf-8 -*-`
 * add `help` directory to contain troubleshooting documentation
 * for now, remove `gem`: `simplecov` and temporarily stop tracking LOCs coverage until JRuby extensions are added in
 * extend usage of pre-processing for C files
 * increase scope of performance RSpecs, light adjustments to remaining RSpecs for clarity & future scope
 * add various aliases to existing Ruby functions/fields/constants/etc

| class           | base reference                          | alias         |
| --------------- | --------------------------------------- | ------------- |
| `Object`        | method: `object_id`                     | `🆔`          |
| `Object`        | method: `freeze`                        | `❄`          |
| `Object`        | method: `frozen?`                       | `❄?`         |
| `Array`         | method: `∑`                             | `each`        |
| `Array`         | method: `⨍`                             | `map`         |

 * added the following methods:

 | class    | method added     |
 | -------  | ---------------- |
 | `Array`  | `>>`             |
 | `Array`  | `⊕`              |
 | `Array`  | `∖`              |

 * add/replace various Ruby functions with native C-extensions (`ruuuby/ext/ruby_class_mods/ruby_class_mods.c`):

 | modified class   | funcs added/replaced  |
 | --------------- | --------------------- |
 | `Object`        | `hsh?`                |
 | `Array`         | `remove_empty!`       |

---

# `v0.0.7`
 * add gem `'rake-compiler', '~> 1.1.0'` to group `development`
 * adjust `bin/audit`, `ruuuby.gemspec`, `Rakefile`, etc to support native C-extensions
 * added section `project layout` and update formatting to `README.md`
 * replace various Ruby functions with native C-extensions (`ruuuby/ext/ruby_class_mods/ruby_class_mods.c`):

 | modified class   | funcs replaced                          |
 | --------------- | --------------------------------------- |
 | `Object`        | `ary?`, `bool?`, `int?`, `str?`, `sym?` |
 | `NilClass`      | `empty?`                                |

---

# `v0.0.6`
 * add {`Ruuuby::Enum::Text`}
 * minor changes/functions-added to DRY some code
 * add `Gemfile.lock` to `.gitignore`

 | class    | method added     |
 | -------  | ---------------- |
 | `Object` | `sym?`           |
 | `String` | `>>`             |
 | `String` | `ensure_start!`  |
 | `String` | `ensure_ending!` |

---

# `v0.0.5`
 * for time being, remove ruby `v2.7` requirement
 * `freeze` various constants and modules
 * slightly clean-up (with helper functions) and expand RSpec scenario coverage

 | class    | method added |
 | -------- | ------------ |
 | `Object` | `str?`       |

---

# `v0.0.4`
 * add gem `'rspec-benchmark', '~> 0.5.1'`
 * remove file `.rpsec`, add rspec configurations through code
 * add performance tests along with a few missed ones
 * update `ruuuby.gemspec` to require ruby `2.7.0`
 * split testing into the following groups:

| category            | command                              |
| ------------------- | ------------------------------------ |
| all but performance | `bundle exec rake rspec`             |
| only performance    | `bundle exec rake rspec_performance` |
| all tests           | `bundle exec rake rspec_all`         |

---

# `v0.0.3`
 * modify `Ruuuby::Enum::Emoji` from `Strings` to `Symbols`
 * fix gemspec to reflect correct git URLs

| added path | reference | notes |
| ---: | --- | --- |
| `lib/class/ary.rb` | ``Array`` |  |
| `lib/class/int.rb` | ``Integer`` |  |

| class | method(s) added |
| --- | --- |
| `Object` | `int?` |
| `Object` | `ary?` |
| `Array` | `remove_empty!` |

---

# `v0.0.2`
| class | method(s) added |
| --- | --- |
| `Object` | `bool?` |

---

# `v0.0.1`

| added path | reference | notes |
| ---: | --- | --- |
| `CHANGELOG.md` |  |  |
| `lib/ruuuby/class/nil.rb` | `NilClass` |  |
| `lib/ruuuby/enum/emoji.rb` |  | `Ruuuby::Enum::Emoji` |
| `bin/audit` |  | for running rdoc, rspecs, and coverage reports |

| class | method(s) added |
| --- | --- |
| `NilClass` | `empty?` |

---

# `v0.0.0`

---

repository: utarsuno/ruuuby

repo_name: utarsuno/ruuuby


text:
---
title: About
subtitle: The long version.
---

Since there's enough to get by with on the front page, I assume you're here for the longer version, so… here we go!

If you're trying to figure out what in the world “sympolymathesy” means, I wrote about it [here](https://v5.chriskrycho.com/journal/relaunch!/#1-new-site-title).

## First things first

Self-biographies are a bit weird. No two ways around it. But they *do* give us a chance to think about how we present ourselves to the world. So when I say—

{% include 'blocks/short-about.njk' %}

—well, the order is careful and the word choice precise. The first things on my personal bio—“a follower of Christ, a husband, and a dad”—are where they are because everything else on the list is both less important than those first three and profoundly informed by them.

### A follower of Christ

The single most important fact of my life is that, to quote [Saint Paul](https://www.esv.org/1+Corinthians+6/): I am not my own, but I was bought with a price—and that price was the death of Jesus Christ, God-the-Son, in my place.[^on-1-cor-6]

I am specifically a Christian in the historic Reformed tradition—aiming always to be irenic, catholic, and orthodox. We’re glad members of [Forestgate Presbyterian Church][forestgate] in Northern Colorado Springs, where I serve in various lay leadership roles.

[forestgate]: https://forestgate.org

[^on-1-cor-6]: Paul was writing specifically about sexual immorality—but the form of his argument is to ground that specific injunction in a very sweeping, indeed a totalizing, claim about the Christian life.

### A husband and a dad

After following Christ, my family is far and away the most important part of my life. Jaimie and I got married in July 2009, and our daughters Elayne and Kate were born in May 2012 and May 2014.

(This site focuses on my public *thinking*; for occasional family updates see [Not a Hint of Hyperbole](https://krycho.com).)

[![Krycho family, May 2020](https://cdn.chriskrycho.com/file/chriskrycho-com/images/family-2020-thumb.jpeg)](https://cdn.chriskrycho.com/file/chriskrycho-com/images/family-2020.jpeg)

## By trade

Since graduating college, I have been working more or less full-time in the software industry—starting out writing avionics software and then hazards and risk mitigation software for the energy industry while picking up web development on the side and eventually transitioning into web development full time. You can see my [CV](/cv/) for the nitty-gritty professional-historical details! Below are just the salient bits of what I’m doing *right now*.

*[CV]: curriculum vitae

### LinkedIn

I’m currently a Staff Software Engineer at LinkedIn, working on front-end infrastructure for what most people think of when you say LinkedIn: the app you sign into, send messages and read updates on, etc. I’m currently supporting our adoption of [Ember Octane]—a project I’ve been doing prep work for in the app since August 2019. I also regularly work closely with a number of the Ember core team members on design of upcoming features, and since 2017 (well before I joined LinkedIn) I have been one of several people driving forward [TypeScript] adoption in the Ember community.

[Ember Octane]: https://emberjs.com/editions/octane/
[TypeScript]: https://www.typescriptlang.org

## By vocation

I have increasingly come to see much of my *calling* in life as that of the public theologian. Doing public theology means (at least) two things:

- doing theological work *for* the church *in* public
- doing theological work *from* the church *for* the public

When I am doing theological work *for* the church *in public*, I aim for the good of the church. It is not merely for intellectual interest; when it is, I’m off the rails. The point of this kind of public theology is to equip other Christians to think well: God and his work in our world, and of our right response to his work.

When I am doing theological work *from* the church *for* the public, I aim for the good of the world in which the church is set. As with work for the church, this cannot be merely a matter of satisfying my curiosity. It also cannot be done *solo*: “public theology” done outside the church—that is, not *from* the church—is also off the rails. My aims in this mode are to make Christianity intelligible to those for whom it is simply perplexing, and to apply robustly Christian thought to matters of the day.

These two modes are complements—not competitors. Done well, each benefits the other.

## By hobby

### A writer

Since college, I have written—a *lot*—primarily on various iterations of chriskrycho.com, but also occasionally at [Mere Orthodoxy], and between January 2018 and June 2020 also in [my newsletter]. I increasingly conceive of my public writing along two axes:

[Mere Orthodoxy]: https://mereorthodoxy.com
[my newsletter]: https://buttondown.email/chriskrycho

- public theology: writing in line with that vocation of public theologian is the work that I care most about, though it is also the work that is hardest in many ways: it’s where the bar is highest.

- public learning: encouraging a culture of learning by sharing what I’m learning—both so that the things I learn, others gain benefit from, and so that I myself have a good trail to follow in the future!

### A runner

Since 2010, I have been a long-distance runner. A bout of mono left me incredibly weak, and a desire to get back in shape to play [Ultimate] with friends led me to spend a lot of time running over the next year. The running stuck: I *miss* playing Ultimate, but nothing stops me from running regularly. I’ve also completed a super sprint triathlon, and cycle regularly… but running is my favorite.

[Ultimate]: https://en.wikipedia.org/wiki/Ultimate_(sport)

### A podcaster

In January 2014, my long-time friend [Stephen Carradini] and I launched [Winning Slowly]—a podcast about tech, religion, ethics, and art. He calls it a tech podcast with other angles; I call it our excuse to talk about literally every part of human existence. We’re both right. And you wouldn’t be wrong to see it as another spot where I consciously practice public theology.

[Stephen Carradini]: https://stephencarradini.com
[Winning Slowly]: https://winningslowly.org

Out of that initial experiment (still running!) grew a general interest in podcasting as a medium, and a variety of podcasts I’ve hosted over the years:

- [New Rustacean](https://newrustacean.com)—my 3½-year-long podcast about the Rust programming language, in which I tried something that as far as I know no one else had done before: teaching a programming language through a podcast.

- [Sap.py](https://sap-py.krycho.com)—an early foray into podcasting with my wife during her brief experiment learning Python

- [Run With Me](https://runwith.chriskrycho.com)—an experimental “microcast” (with episodes always under 10 minutes long), recorded *while running* at various points in 2016.

- [Mass Affection](https://massaffection.com)—another foray into podcasting with my wife, this time about the video game series Mass Effect. We aspire to finish this… eventually. It’s been hard to carve out the time for it the last couple years, but we always enjoy it when we do!

I find podcasting a great complement to writing. It is available in spaces and places where people cannot read (like commuting), and it’s also a great place to flesh out thoughts I have already put in writing or am trying to figure out how to put in writing.

### A composer

In high school and college, I studied and practiced musical composition, mostly in a neoclassical/neoromantic vein. Since graduating college, I have composed relatively little, but it remains a delight when I get a chance to do it. I composed the processional for my own wedding as well as both of my little sisters’ weddings and the themes for all of my podcasts, and actually have a few things actively in work (if on the back burner). You can check out a limited sample of my work (which I hope to expand soon, for the curious if nothing else) [on SoundCloud].

[on SoundCloud]: https://soundcloud.com/chriskrycho/tracks

repository: chriskrycho/lightning-rs

gha_language: SCSS

repo_name: chriskrycho/lightning-rs


text:
title: Networking
category: page
slug: networking
sortorder: 0440
toc: False
sidebartitle: Networking
meta: Understanding computer networking is critical to building reliable, performant Python web applications.

Computing networking is critical to building reliable, performant Python
web applications.

### Resources about networking
The "Let's code a TCP/IP stack" series along with its
[open source code](https://github.com/saminiir/level-ip) gives a ton of
context on how TCP/IP works while providing the code for implementing the
foundational pieces. You will likely need to pair this with a more theoretical
reference tutorial such as [RFC 1180](https://tools.ietf.org/html/rfc1180)
to have a more complete understanding of the protocol:

1. [Ethernet & ARP](http://www.saminiir.com/lets-code-tcp-ip-stack-1-ethernet-arp/)
1. [IPv4 & ICMPv4](http://www.saminiir.com/lets-code-tcp-ip-stack-2-ipv4-icmpv4/)
1. [TCP Basics & Handshake](http://www.saminiir.com/lets-code-tcp-ip-stack-3-tcp-handshake/)
1. [TCP Data Flow & Socket API](http://www.saminiir.com/lets-code-tcp-ip-stack-4-tcp-data-flow-socket-api/)
1. [TCP Retransmission](http://www.saminiir.com/lets-code-tcp-ip-stack-5-tcp-retransmission/)

* [Monitoring and Tuning the Linux Networking Stack: Receiving Data](https://blog.packagecloud.io/eng/2016/06/22/monitoring-tuning-linux-networking-stack-receiving-data/)
  along with
  [Monitoring and Tuning the Linux Networking Stack: Sending Data](https://blog.packagecloud.io/eng/2017/02/06/monitoring-tuning-linux-networking-stack-sending-data/)
  are incredibly detailed technical posts on the networking layer within
  Linux operating systems.

* [Computer networking](http://cnp3book.info.ucl.ac.be/) is a free book
  that explains how networking between computer systems works. There are
  also exercises for testing what you learned along the way.

* [What's the history behind <IP_ADDRESS>? Why not <IP_ADDRESS> or any other IP address? When did it start being used? Who started it? Why? Why not <IP_ADDRESS>? What is the relation to <IP_ADDRESS>? What about <IP_ADDRESS> (Apple)?](https://www.quora.com/Whats-the-history-behind-192-168-1-1-Why-not-192-169-1-1-or-any-other-IP-address-When-did-it-start-being-used-Who-started-it-Why-Why-not-1-1-1-1-What-is-the-relation-to-127-0-0-1-What-about-10-0-0-1-Apple)
  is a nice answer on the history of IPv4 addressing and why various
  IP addresses such as <IP_ADDRESS> became standards for localhost or
  other local networking.

* [We built network isolation for 1,500 services to make Monzo more secure](https://monzo.com/blog/we-built-network-isolation-for-1-500-services)
  provides the thinking, processes and data analysis behind how one
  team took a complex environment, separated the dependencies and
  was able to improve their network. It's a great case study-style
  article that has more detail than a lot of similar operations posts.

* [Dropbox traffic infrastructure: Edge network](https://blogs.dropbox.com/tech/2018/10/dropbox-traffic-infrastructure-edge-network/)
  explains how Dropbox uses edge-of-the-network resources closer to the
  end user to optimize performance of their service.

* [On the shoulders of giants: recent changes in Internet traffic](https://blog.cloudflare.com/on-the-shoulders-of-giants-recent-changes-in-internet-traffic/)
   examines how the COVID-19 pandemic of 2020 changed the times during the
   day and locations of how the majority of internet traffic was routed
   and consumed.

gha_language: HTML