#
Week 1 | Semantic HTML
Date written: 2020-10-10
Semantic HTML is a feature of modern webpages that allows for
elements to be defined semantically. This differs from standard
HTML, where logic and style are added using classes and IDs. For
example,

versus,

These differ in a few ways. For one, the

element inherits nothing outside of what's
already included with the div element. Additionally, it sets up the
class .article
for use with selection with CSS or
jQuery.
Alternately, the
article
element inherits from the standard div, and
also from the standard article object. In this case, there's nothing
outside of display: block;
, however in other cases this
is significant. Additionally, the CSS selector for this element is
article
, without the .
or
#
that comes along with Classes and IDs respectively.
(w3schools, n.d.)
There's a bunch of these elements which carry their own inherited
style and logic, but some of the lesser used ones include:

, , ,
,
 , , , , , ,
, , <time>
Article References
#
Week 2 | Object-Oriented CSS
Date written: 2020-10-17
Object-Oriented CSS is a set of implicit conventions for CSS that
names values based on what they would normally be in an
object-oriented language. Traditional CSS has no restrictions for
class and ID names, allowing anything including the names of
semantic elements. For example, a .nav
class is fully
allowed, even in spite of the existing

element.
A good example of this kind of convention is Oxygen, a convention
for CSS designed around applying the OO method to naming elements in
stylesheets (Oxygen, n.d.). This convention is
fairly similar, with only 4 types of objects included in the
specification. These are:
| Object |
.button
.menu |
.noun |
| Child-Object |
.button-caret
.menu-item |
.noun-noun |
| Subclass |
.primary-button
.popup-menu
|
.adjective-noun |
| Modifier |
.is-selected
.scrollable |
.prefix-adjective or
.adjective
|
(Oxygen, n.d.)
Using this framework, it's possible to have a form of inheritance,
whereby child-objects assume the style of their parent objects. For
example:
<button class="btn btn-warning"></button>
Follows a similar process to .btn-warning
being truly
inherited from btn
. As both classes are in use on the
object, btn-warning
can include modifications on the
core btn
class to turn it into a warning button, much
like how inheritance works in other languages.
This convention can help to standardise object styles, as any
deviation from a standard object inherits from the main object much
like in a true OO language. Using this, modifying
btn
will change all buttons, regardless of the child
type each button on the page uses.
Article References
#
Oxygen, (n.d.). An object-oriented methodology for stylesheets.
[online] Available at:
http://oxygencss.com/
[Accessed 2020-12-17].
#Week 3 | SASS/SCSS
Preprocessing
Date written: 2020-10-24
Sass (and SCSS) is a versatile and mature CSS extension language
that allows for the utilisation of more complex features, such as
variables and shorthands, as well as simplifying the stylesheet
development process. Sass is compiled into native CSS, and is
generally far less complex than standard CSS. For this reason, Sass
is used in modern web development because of it's raw power compared
to pure CSS and the reduction in complexity it affords.
One key element in what makes Sass useful is it's handling of
variables, which differs from CSS variables in a few key ways. This
includes how the variables can be modified and have scope, unlike
with CSS, and can additionally include more complex data like for
shadows and borders. For example:
$base-color: #c6538c;
$border-dark: rgba($base-color, 0.88);
.alert {
border: 1px solid $border-dark;
}
Will be compiled into:
.alert {
border: 1px solid rgba(198, 83, 140, 0.88);
}
This is particularly useful as it allows for variables to be used
for site-wide consistency. There's many more complex features that
Sass affords, which are fully documented
(Sass, 2020). Worth mentioning is that valid
SASS/SCSS must be compiled for use on the web, adding a small extra
step to deployment. This can be worked into a workflow like with
node or a standard shell script using the command:
sass input.scss output.css
This will build the SCSS file into CSS, ready for deployment.
There's an argument to be made that this extra step can be
detrimental, however I believe that the extended functionality can
be a huge advantage, especially so when integrated into the
development and deployment workflow.
Article References
#Week 4 | Flexbox
Date written: 2020-10-31
Flexbox is a great modern web technology that can be very powerful
for responsive design and efficient page layout, without any of the
complexity of calculating the size of objects using javascript. It
can arrange boxes based on different directions, different scaling,
filling, aligning, ordering, wrapping, with many other applications.
As a demonstration, here's a simple chart showing the different
types of barbecue sauce:
Tomato based
Vinegar based
Mustard based
This chart is a flex container div, with divs inside of that
container that have the
flex-grow property set to 1.
This makes it so that the boxes grow and shrink to have an even
amount of width between the three. Equally, you can add as many
boxes as you'd like, and it'd scale them proportionally. This can be
utilised in lots of ways, with the
flex-grow property allowing
elements to have a scaling ratio. In these examples, all the
elements have an equal ratio, however it's possible to have two
boxes with largely different scales.
One of the most popular applications for flexbox is in HTML forms,
as it can be very useful for having multiple inputs on one line. In
this example, there's a username and a password field on the same
line, separated by a small gap. This can all be done in flexbox very
easily:
Overall, I consider flexbox an essential skill. I've learned a small
amount about it during this course, but it's utility has always been
clear to me. I particularly like how useful it is for aligning
cards, as those are notorious for being difficult to size and
position when creating a responsive webpage. All of my knowledge of
flex comes from a single source, a wonderful guide hosted by
CSS-TRICKS (2020).
Article References
#Week 5 | JavaScript &
TypeScript
Date Written: 2020-11-05
Much like Sass, TypeScript is a superset of JavaScript, whereby all
valid JavaScript is also valid TypeScript. It transcompiles into
pure JavaScript, affording the ease of working with static typing
and additional functionality. The primary differences between
JavaScript and TypeScript come about in the implementation of strong
typing with the latter (TypeScript, 2020).
Strong typing involves defining what type a variable will use and
additionally prevents implicit type conversion, which is a large
part of why vanilla JavaScript is disliked. This strong typing looks
like this:
// JavaScript Approach
let i = 64;
// TypeScript Approach
let i: int = 64;
This is an example of TypeScript's strong typing, enforcing a
variable type at assignment. On top of this, TypeScript allows for
custom types, using type
and interface
:
// types are objects that have a state based on values
type DoorState = "open" | "closed";
// interfaces are comprised of member objects
interface User {
name: string;
id: number;
}
These features can be essential for writing more complex systems, as
tranditional JavaScript can be quite clunky without any typing like
this (rafpaf et al., 2020).
Additionally, TypeScript allows for static typing, which changes the
definition from using instantiation to having a static value. While
TypeScript can handle instantiation (i.e. instances of), having the
additional static capability can be greatly useful in certain
applications. An example of this would be:
class Person {
static species: string = "Human";
}
Using this example, it's clear to show that each Person object will
always have the species of "Human". It's static in that it won't
change based on instantiation
(orta et al., 2020).
Article References
#Week 6 | JS Code
Highlighting
Date Written: 2020-11-14
This section is going to cover the code blocks used on this site.
I'm using the script Prism.js, a lightweight and modular syntax
highlighter. On top of this, I'm using a modified version of the
Tomorrow Night theme. This script looks for language classes within

blocks. It then styles the elements inside
the block based on a language module
(Golmote et al., n.d.). For example:
use apres::MIDI;
use std::path::Path;
fn main() {
let file_name = "Target-File.mid";
let path = Path::new(".").join(file_name);
println!("reading from {:?}!", path);
read_file(path);
}
Above is a code snippet in the language Rust, a low-level language
occupying a similar space to C or C++. The snippet has coloured text
lining up with the elements in the code. To display this, I use the
following syntax:

fn main() {
println!("Hello World");
}

The class lang-rust
specifies what language is in the
code block, which controls the syntax highlighting and the language
readout in the top right. Prism also has extensions, including one
for the command line:
sudo apt update
This extension adds some extra flavour to the code block, while
still correctly highlighting the command as shell (or, more
specifically, bash). This is written as:

sudo apt update

This functionality can be very useful for a blog like this, as it
lets me put code snippets right into the webpage without needing to
embed an iframe to a GitHub Gist or manually format the script.
Additionally, I can revise elements in the code tags, updating
what's there or adding or removing elements very easily. Finally,
the style that this afford is very useful, as I can easily change
the overall theme that the highlighting uses.
This shows how useful FOSS web-scripting can be, as there's always
going to be a module somewhere out there that does what you want,
and adapting them and utilising them can be half the battle in web
development. This will be expanded upon greatly in the next few
segments.
Article References
#Week 7 | jQuery
Date Written: 2020-11-21
Although modern web development has largely abandoned jQuery in
favour of pure JS and other frameworks like React or Vue, jQuery
still has a presence, being used in web development and bundled
alongside popular libraries like Bootstrap v4.5.x (No longer true
for ^5.0.0) (XhmikosR et al., 2020).
jQuery is a useful library for "DOM Traversal and Manipulation",
Event Handling, and Ajax
(dmethvin et al., 2020), each of which
I'll describe below:
DOM Traversal and Manipulation
jQuery's most commonly used feature involves the easy selection of
DOM elements much like with CSS. Each DOM element on a page has an
element type, and can have a class, multiple classes, or an ID.

This element above has a few features that can make it very easy to
manipulate in CSS. These include the header
element,
the .header
and .layout-top
classes, and
the #main-header
id. A CSS file that manipulates these
values will look like this:
/* Semantic Element */
header {
...
}
/* Classes */
.header {
...
}
.layout-top {
...
}
/* ID */
#main-header {
...
}
The selector that doesn't have any punctuation refers to the
semantic element of header
, while the dot refers to
classes, and the hashtag/pound sign refers to an ID. The usefulness
of jQuery is that this functionality is preserved, allowing for the
following:
// Change the value based on a semantic element
$("header").html("Welcome to the site");
// Perform a function for each Class
$(".header").each(function () { ... });
// Hide the element based on ID
$("#main-header").hide();
(jQuery, n.d.)
This simple syntax makes jQuery very appealing for developers, as
having knowledge in CSS Selectors makes it very easy to implement
jQuery in a practical way.
Event Handling
jQuery can also be used to handle events, extending the basic
JavaScript event functionality. While PureJS events rely on HTML to
implement the event functionality, jQuery can add events to elements
based on selectors in the script. For example, two alternate methods
to implementing a click event for a button:
<button onclick="click()" />
$(button).on("click", function (event) { ... });
While these are both functionally similar, jQuery implements this
without requiring any in-HTML event handling. This can be very
useful for maintaining clean code. Additionally, the quantity of
events that jQuery can handle is much greater than that of pure
HTML/JS, as signified by their documentation on the issue
(jQuery, n.d.).
Ajax
Arguably the most useful side of jQuery is Ajax, a wrapper for HTTP
Requests. HTTP requests allow for sites to interact with other
servers easily, using various request methods to communicate
(w3schools, n.d.). Usually HTTP requests are
confined to forms, and allow for clients and servers to interact.
Ajax exposes this functionality in a practical manner, allowing for
developers to perform asynchronous HTTP requests without the usage
of forms (jQuery, n.d.).
I've implemented HTTP requests in my own projects commonly recently,
including an automation script for the university network and for
fetching repos from GitHub's REST API.
This function fetches all of the public repositories from my GitHub,
then converts them to JSON data ready for other scripts to display
the data on the page.
componentDidMount() {
fetch("https://api.github.com/users/summerysaturn/repos")
.then((res) => res.json())
.then((data) => {
this.setState({
restData: data,
});
});
}
Modified source code from my project, summerysaturn.github.io
This Bash script assigns a GET request to the variable $get, ready
for handling later on with a grep
. This mimics a GET
request for loading a page, which assigns a SESSID cookie for the
POST request in the script later on.
get=$(
curl -s -o /dev/null -D
- 'https://firewall-auth.brighton.ac.uk:6082/php/uid.php?vsys=1&rule=2'
-A 'WorldWideweb (NEXT)'
-H 'accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8'
-H 'accept-encoding: gzip, deflate, br'
-H 'accept-language: en-GB,en;q=0.5'
-H 'connection: keep-alive'
-H 'upgrade-insecure-requests: 1'
)
Modified source code from my project, lyla-dotfiles
Ajax allows for this functionality in JavaScript, without the
requirement of a large library like React (as above). This allows
for the same functionality to exist in a webpage. For example, the
jQuery documentation has a few example requests, including this one
(jQuery, n.d.):
$.ajax({
url: "script.php",
method: "POST",
data: { id : menuId },
dataType: "html"
});
jQuery isn't strictly necessary for HTTP requests, as it's only a
wrapper (You Don't Need jQuery!, 2014), but the
same is true for many of the things jQuery implements.
Article References
#
dmethvin et al., (2020). jQuery. [online] Available at:
https://jquery.com/ [Accessed
2020-12-17].
# Week 8 | Node.js
Date Written: 2020-11-28
Node.js is an non-blocking JavaScript runtime that can be used to
build applications hosted on the web
(XhmikosR et al., 2020). What this means
is that it's an environment that can execute JavaScript much like a
web browser, without any of the web frontend that comes with a
regular browser (Gibb, Robery, 2020). The
non-blocking part refers to how many connections can be handled
concurrently without holding up a thread
(Capan, n.d.).
The primary utility of Node.js is on the server as a backend, as it
is primarily useful in how it handles connections concurrently. This
being said, I've found particular use for Node.js using package
managers like NPM and Yarn, as it can help to build applications
using frameworks like React.js and Electron.
node
Welcome to Node.js v14.15.0.
Type ".help" for more information.
>
In the command line, Node.js can be utilised to execute JavaScript
easily as a scripting language, which is what NPM and Yarn both run
on (Node.js, 2011). These package managers fetch
packages from the NPM Registry
(w3schools, n.d.) and install them either
globally or in the local directory. This can be used to set up
dependencies in a JavaScript project, allowing for easier sharing
and version management when compared with traditional solutions.
Each local directory that utilises Node.js has a
package.json
file which includes details about the
package, along with the dependencies, license, repository, author,
etc. This information is very useful to include in the root of a
repository.
{
"name": "countdown-applet",
"version": "1.0.0",
"description": "A minimal Electron countdown app",
"main": "main.js",
"scripts": {
"start": "electron ."
},
"author": "GitHub",
"license": "MIT",
"devDependencies": {
"electron": "^8.5.2",
"electron-reload": "^1.5.0"
},
"dependencies": {}
}
Modified source code from my project, countdown-applet.
My primary utilisation of Node.js comes from the utilisation of a
few frameworks, including Electron, TypeScript, Sass, Webpack,
Bootstrap, and a few others.
Electron-Forge is a
preset project that has all the dependencies needed to produce
Electron apps using Node. Electron itself is described in
Week 11's Article.
Article References
# Week 9 | React
Date Written: 2020-12-05
ReactJS is a JavaScript library designed around component-based UI
(Facebook, 2021). It's unique in that it has a
specific method of rendering elements, differing greatly from
traditional web design. This is difficult to learn, however it
affords ReactJS a lot of versatility and performance.
A major part of this element style relate to Component Props and
Component State. The diagram below illustrates this:
(Holla, n.d.)
Props are passed down from parent elements, whereas State is
self-referential for each component. This data flow outlines how
components affect each other, and how parent elements have priority
over child elements. Additionally, state can be used to affect how a
component renders, by re-rendering whenever state changes
(Holla, n.d.).
(Holla, n.d.)
Additionally, each component has a large amount of callbacks
relating to it's own lifecycle, allowing for lots of granularity
over what a component should do at each point in the lifecycle. This
can have many practical implications
(Holla, n.d.).
class ClassComponentExample extends React.Component {
constructor(props){
super(props);
console.log('Constructor State')
this.state = {
messageB1:"Default Message B - 1",
messageB2:"Default Message B - 2",
}
}
render() {
console.log('Render State')
return

{this.props.message}

{this.state.messageB1}

{this.state.messageB2}

<button onclick="{this.b1OnClick}">B1 Button</button>
<button onclick="{this.b2OnClick}">B2 Button</button>

}
}
Modified source code from Holla (n.d.)
ReactJS is far too complex to sum up in this blog, but this should
be a decent starting point. ReactJS is something I've used in a
couple of projects already, and it's a useful skill for the
industry, as it runs a fair amount of the modern web. Facebook
itself is written on React, explaining why Facebook is cited for
this article.
Article References
# Week 10 | WebPack
Date Written: 2020-12-12
With the internet getting larger and larger, technologies aiming to
cut down on extraneous data usage are essential. The speed at which
a page loads is largely dictated by the optimisation put into the
webpage design. Webpack aims to solve an issue where many files are
sent when a page is loaded due to dependencies, instead packaging
all the dependencies for a page into a smaller payload.
Webpack functions by identifying the usage of modules and
dependencies in your JavaScript, CSS, Sass, etc., and packages them
all into a minified file that they call a Static Asset. These assets
are delineated by type, including JavaScript, CSS, and images.
(Webpack, n.d.)
I'm using this in my modern Node/Electron projects, as Electron
Forge includes Webpack as an option natively
(Electron Forge, n.d.). The ease of webpack
comes from how you can drop it into an existing Node project, set it
up, then forget about it; it's effectively free optimisation,
provided that no issues come up.
Article References
# Week 11 | Electron
Date Written: 2020-12-19
Electron is a framework originally designed for the text editor
Atom, having evolved since it's 1.0 release in 2014
(Marcin and Olga, 2020). The framework is now
utilised by many different applications, including Slack and Visual
Studio Code (Electron, n.d.). The utility of
Electron comes from how it allows for you to create a desktop
application using HTML, CSS and Javascript, being a Node package
(Marcin and Olga, 2020).
Electron solves an issue in the programming industry whereby good
cross-platform UI Frameworks are hard to get ahold of. This issue is
solved in Electron by effectively shipping a web application as a
desktop app, one of the few things that are easy to use and react
consistently regardless of host operating system; Windows relies
upon it's own UI library
(Bridge, Schofield, 2020), MacOS has a couple
(Apple, n.d.) (Apple, n.d.),
and Linux has multiple frameworks (Gnome, 2021)
(The QT Company, 2020). Electron sidesteps this
issue entirely, having everything rendered entirely as a webpage.
Electron has drawn criticism around utilising the web stack for
general purpose GUI, replacing those native UI toolkits that work
with low level languages. The fact that every instance of an
electron app is a whole browser instance affects performance in a
big way, with Electron apps being notorious for using lots of memory
and being far less performant than a binary application
(Rory, 2017) (Ohno, 2018).
I personally understand the concerns about Electron and utilise it
in spite of that, as it's a very accessible framework for someone
used to front-end web design. In the future I might learn something
like GTK, however for now, Electron is useful for app development.
Article References
#
The QT Company, (2020). UIKit. [online] Available at:
https://www.qt.io/
[Accessed 2021-01-06]


Across: 1. My, my! Rest gives some sort of balance (8) 5. Where rogues run - fine after the morning (4) 9. Blokes to return, but be without toast (4) 10. One who gets who? Mexican carer? (8) 11. Showing (13-Across), even if not chums (5) 12. Born to a circle of slight (13-Across) (7) 13. ? (13) 18 (13-Across) of confused morality (8) 19. Examine match (4) 20. Man, it is some type of believer! (7) 21. Rap is arranged for duets... (5) 22. ...to play, with "Yo" back in the street... (4) 23. ... (can such machismo do me terrible harm, cut on the dash?)... (8) Down: 2. ...progressive music? "Yo" with knockout monotonous sample, ... (4,3) 3. ...simple creature - dim doll, dud disc, no identity (7) 4. Restored to original (13-Across), repairs enticed tours (13) 6. Drink mixed in at rim? (7) 7. Shane, go rekindle the fire, and return with fuel-charged rock (7) 8. Give a bloke an "A" in the country? (6) 13. Deal with (13-Across) (7) 14. Do as my fill undoing your empty - take it back (7) 15. What has six legs, and the attention and hair of a judge? (6) 16. Alien art - it returns, (19-Across) (13-Across) ... (7) 17. ... probes assets, pores over hearts ... pay attention! (7)


{% extends "layout.html" %} {% block title %}Embed a secret message{% endblock %} {% block content %}
TODO: Put the stuff here that allows me to upload a file and put in a message


New Arrivals On Sale
Special for today
30 Days return
Free shipping
New products
Best Quality mobiles & Long Life Accessories.
Best design Home furniture and Variety of Kitchen Products.
Stylish designers Branded Clothes & shoes.


Must be between 8 and 256 characters long and contain:
- at least 1 numeral: 0 - 9
-
at least 1 of the following:
-
alpha character, case-sensitive a-Z
-
any of the following symbols:
! @ # $ % ^ * ( ) ~ ` {{ '{ }' }} [ ] | \ & _
-
optionally the space character,
i.e ' ' and other punctuation such as . , ;
Example: sun% moon2
ORCID does not allow common passwords. Common passwords are insecure,
easily-guessed words or phrases such as 'qwerty123'.
See the full list of common passwords we don't allow on ORCID


| DOSE: T+ 0:00 |
15 mg |
oral |
5-MeO-DiPT |
(powder / crystals) |
| T+ 5:00 |
1 bowl |
smoked |
Cannabis |
(plant material) |
I am not what I would call an experienced tripper. I have tripped on mushrooms 3 times, DXM 4 times, salvia twice, E once, and AMT twice, but I would not call my AMT experiences, they just consisted of a very minor mood change, and a significant headache. My largest AMT dose was 42 mg, which for most people is enough for a significant experience. Due to this tolerance I guess you would say, I decided to take a slightly larger dose than most people for the foxy. The scale used is not accurate to .001, but I do know that my dose was somewhere around 15 mg.
I decided to trip by myself in my room after my parents went to sleep. I had a capsule with the foxy and some loperamide in it due to the many reports of diarrhea. I think this helped a lot. I took the pill at 10:30 PM.
T + 7 min: Already feeling first alerts. I was somewhat concerned by this as I do not like overwhelming experiences. Nothing big yet, but definite pre-trip feeling.
T + 11 minutes: Already seeing edges undulate and wave. I was started to get scared that I might have taken a bit too much.
T + 15 minutes: Full blown OEV's at this point. Very much like I hear acid described. Many colors, and the 'breathing' effect. I begin to feel a sense of panic inside me. I am shooting up rapidly
T + 30 minutes: The come up is very uncomfortable and it comes in large spurts. Right when i think I am beginning to level off, I shoot up a knotch. The auditory effects are very interesting. Not only do I notice a chage in pitch, but full on auditory hallucinations. I would be lying in bed and start to hear typical jungle noises as well as sounds of the city (ie. crickets, tigers, cars, conversations, bells ringing). Everytime I would shoot up higher, the auditory hallucinations would go with it. I would feel OK, then I would start to hear more and louder things very rapidly and it became more and more intense till finally it leveled off, but would then start again.
T + 45 minutes: The body load is very uncomfortable, I can feel a very distinct energy in me. I made a call on the telephone, and the dial tone sounder very strange, a LOT lower than normal. The open and closed eye visuals are amazing, patterning, tracers, typical psychedelic, but with a unique feel. I am still coming up.
T + 75 minutes: I feel I am finally peaking, thank god. This is too much for me to handle. There is some disassociation and a lot of panic. The visuals are amazing. To me, foxy feels a lot more like what I have heard 2ct7 described as. I can definitely see where the name foxy comes from, there is definitely and erotic component to it. I also feel muscle spasms everywhere in the body, though they are not unpleasant, they actual feel kind of good. The spasms actually go along with the nature of the trip, very sporadic.
T + 3 hours: I finally feel like I am beginning to come down. This makes me feel a little relieved. Music is extremely weird to listen to, I wonder 'How can this be the normal music I listen to every day?' The visuals are still going strong, but the buzzing energy in my body is beginning to subside.
T + 5 hours: I am pretty much down. There is an afterglow and some visuals still. I decide to smoke a bowl which brings all the good components of the trip back, but not the body sensations. Sleep is very difficult and I don't imagine it would have been possible with out the weed. I finally get to sleep at 6:30 AM.
Overall I think is can be a great substance. I just took to large of a dose. One thing I noticed was that I had to pee about every 15 minutes, which got very annoying after a while. I was surprised with the visuals because most reports dont mention much about them, although there are a few which describe immense acid-like hallucinations. This chemical has extreme potential for me. I like it more than mushrooms. I imagine a dose around 7-8 mg would be much more enjoyable. Can't wait to try it again.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


S02: Bits and Pieces
Lexical Conventions: comments.t
Possible runaway string
(3 skipped)
Excess arguments to CORE eval
(1 skipped)
Opening bracket is required for #` comment
(4 skipped)
Lexical Conventions: unicode.t
VOWEL SIGNs in identifiers
(2 skipped)
PS does not work to separate lines
(1 todo)
Lexical Conventions: unspace.t
86 tests aborted (missing ok/not ok)
(86 aborted)
Failed test
aborted 86 test(s)
indirect method calls
(3 skipped)
.++ does not work
(1 skipped)
=for pod not implemented (in STD.pm)
(4 skipped)
pod and unspace
(3 skipped)
Lists: tree.t
Any.tree(*@list) NYI
(1 skipped)
Literals: autoref.t
Cannot use value like Capture as a Number
(7 skipped)
Literals: char-by-name.t
Unrecognized character name LINE FEED
(1 skipped)
\c[LF] not valid
(1 skipped)
\c[LINE FEED] not valid
(1 skipped)
Literals: char-by-number.t
Detecting malformed escape sequences NYI
(4 todo)
Literals: hash-interpolation.t
Literals: listquote-whitespace.t
\xa0 should not be a separator for list quotes
(1 todo)
Literals: listquote.t
Preceding context expects a term, but found infix , instead
(1 skipped)
meta operators
(1 skipped)
magic type of <...> contents
(3 todo)
Literals: misc-interpolation.t
Action method escape:sym<&> not yet implemented
(3 skipped)
No value for parameter \$index in postcircumfix:<{ }>
(1 todo)
Literals: numeric.t
exactly rounded Str->Num without FatRat
(1 todo)
Literals: pairs.t
Action method escape:sym<&> not yet implemented
(1 skipped)
reduce meta op
(1 skipped)
Literals: quoting-unicode.t
Parse failure
(1 skipped)
Literals: quoting.t
& escape, zen slices
(9 skipped)
Weird quoting issue
(1 todo)
Failed test
156 - \c followed by non-number
Failed test
159 - Escaped opener produces the opener unescaped
q:x assigned to array
(2 todo)
Literals: radix.t
Some question of what this form should actually do
(4 todo)
Literals: version.t
trailing zeroes fail
(3 todo)
Magicals: dollar-underscore.t
infinite loop
(1 skipped)
for() with nullary block
(1 skipped)
Magicals: dollar_bang.t
undefine and Exception NYI
(7 skipped)
stringification of $!
(1 todo)
Magicals: env.t
Action method statement_control:import not yet implemented
(1 skipped)
Cannot call is_run; none of these signatures match
(1 skipped)
import keyword
(1 skipped)
Names Vars: list_array_perl.t
recursive data structure
(2 skipped)
Names Vars: names.t
Undeclared name: Terrain::
(7 skipped)
Postconstraints, and shapes on variable declarators NYI
(4 skipped)
Object reference not set to an instance of an object
(2 skipped)
::{ } package lookup NYI
(4 skipped)
this kind of lookup NYI
(2 skipped)
package variable autovivification
(7 skipped)
dubious test - otherwise why is ::<$foo> allowed?
(1 todo)
Names Vars: perl.t
>>>Stub code executed
(4 skipped)
Unhandled exception
(6 skipped)
{...}.perl does not work
(2 skipped)
recursive data structure
(2 skipped)
Names Vars: signature.t
eqv on signatures
(2 todo)
nom regression
(3 skipped)
Names Vars: variables-and-packages.t
Undeclared routine grtz
(3 skipped)
System.NullReferenceException: Object reference not set to an instance of an object
(8 todo)
nom regression
(3 skipped)
Names Vars: varnames.t
14 tests aborted (missing ok/not ok)
(14 aborted)
Failed test
aborted 14 test(s)
cannot easily override [] at the moment
(2 skipped)
Names: bare-sigil.t
bare sigil % generates postcircumfix:<()> exception
(1 skipped)
++(state $) yields (3, 3, 3) instead of (1, 2, 3)
(2 skipped)
Names: our.t
Null PMC access in invoke()
(1 skipped)
OUR::subname() does not work
(1 skipped)
Names: pseudo.t
various issues, skipping all for now
(36 skipped)
the binding in here is NYI
(4 skipped)
various issues to resolve
(23 skipped)
GLOBAL and interpolation
(1 todo)
binding and interpolation together NYI
(2 todo)
interpolation and auto-viv NYI
(1 todo)
these tests disagree with STD
(2 todo)
not entirely sure these make sense...
(2 todo)
Names: symbolic-deref.t
Object reference not set to an instance of an object
(5 skipped)
no such symbol
(1 skipped)
Types: anon_block.t
No candidates for dispatch to mone
(4 skipped)
Exception NYI
(3 skipped)
tests don't work if previous test fails
(2 skipped)
Parrot support for zero-arg subs?
(1 todo)
Types: array.t
multi-dim arrays
(2 skipped)
coercion syntax
(2 skipped)
*/.. interaction
(2 skipped)
WhateverCode/.. interaction
(1 skipped)
Cannot use value like WhateverCode as a number
(1 skipped)
type constraints
(1 todo)
@arr[-1] returns undef
(1 todo)
Types: array_extending.t
Unable to resolve method exists in class Array
(5 skipped)
min on list with undefined el ignores it
(1 todo)
Types: assigning-refs.t
non-flattening hash refs
(3 todo)
Types: autovivification.t
Unable to resolve method push in type Any
(5 skipped)
https://github.com/sorear/niecza/issues/176
(2 todo)
Types: bag.t
Non-Str keys NYI
(3 skipped)
.grabpairs NYI
(1 skipped)
.pickpairs NYI
(11 skipped)
.total/.minpairs/.maxpairs NYI
(16 skipped)
Unmatched key in Hash.LISTSTORE
(2 skipped)
Bag in Bag does not work correctly yet
(4 todo)
Non-string bag elements NYI
(1 todo)
No longer Iterable
(3 skipped)
Odd number of elements
(2 skipped)
Not properly interpolating
(2 todo)
Types: baghash.t
Non-Str keys NYI
(3 skipped)
171 tests aborted (missing ok/not ok)
(171 aborted)
Failed test
aborted 171 test(s)
'is ObjectType' NYI
(21 skipped)
No longer Iterable
(3 skipped)
Odd number of elements
(2 skipped)
Needs to catch up with spec
(2 todo)
Types: bool.t
2 tests aborted (missing ok/not ok)
(2 aborted)
Failed test
aborted 2 test(s)
Types: capture.t
nom regression
(1 skipped)
Types: catch_type_cast_mismatch.t
questionable test
(1 todo)
Types: declare.t
Comparator not implemented
(1 skipped)
OrderingPair not implemented
(1 skipped)
Complex not type converted properly during assignment from Rat
(1 skipped)
utf8 not implemented
(1 skipped)
buf not implemented
(1 skipped)
Blob not implemented
(1 skipped)
QuantHash not implemented
(1 skipped)
Macro not implemented
(1 skipped)
int not implemented
(1 skipped)
No value for parameter $l in infix:<===>
(1 skipped)
rat not implemented
(1 skipped)
bit not implemented
(1 skipped)
complex not implemented
(1 skipped)
Codepoint not implemented
(1 skipped)
Matcher not implemented
(1 skipped)
Char not implemented
(1 skipped)
junction not implemented
(1 skipped)
utf32 not implemented
(1 skipped)
AnyChar not implemented
(1 skipped)
Grapheme not implemented
(1 skipped)
Failure not implemented
(1 skipped)
CharLingua not implemented
(1 skipped)
Ordering not implemented
(1 skipped)
Bit not implemented
(1 skipped)
StrPos not implemented
(1 skipped)
Duration not implemented
(1 skipped)
utf16 not implemented
(1 skipped)
KeyExtractor not implemented
(1 skipped)
Coercive declarations NYI
(2 skipped)
No Module type yet
(1 skipped)
num not implemented
(1 skipped)
Exception not implemented
(1 skipped)
StrLen not implemented
(1 skipped)
Byte not implemented
(1 skipped)
HyperWhatever not implemented
(1 skipped)
num16 not implemented
(1 skipped)
Integral not implemented
(1 skipped)
Complex not type converted properly during assignment from Num
(1 skipped)
Matcher isa not implemented
(1 skipped)
num16 not implemented
(1 skipped)
int not implemented
(1 todo)
num not implemented
(1 todo)
Types: deprecations.t
tracebacks in deprecations
(29 skipped)
Could not create deprecated Order::Decrease
(1 skipped)
Could not create deprecated Order::Increase
(1 skipped)
Types: hash.t
Excess arguments to Hash.new, unused named a
(1 skipped)
Unsupported use of [-1] subscript to access from end of array
(1 skipped)
auto-vivified binding does not work yet
(1 todo)
Types: infinity.t
Int conversion of NaN and Inf
(3 todo)
Types: isDEPRECATED.t
tracebacks in deprecations
(2 todo)
Types: lists.t
Cannot use value like Capture as a number
(2 skipped)
Excess arguments to CORE List.new
(2 skipped)
Cannot use bind operator with this LHS
(3 skipped)
Types: mix.t
No longer Iterable
(3 skipped)
Odd number of elements
(2 skipped)
Not properly interpolating
(2 todo)
Types: mixed_multi_dimensional.t
Cannot use hash access on an object of type Pair
(8 skipped)
more keys at level 4
(1 todo)
Types: mixhash.t
'is ObjectType' NYI
(21 skipped)
No longer Iterable
(3 skipped)
Odd number of elements
(2 skipped)
Needs to catch up with spec
(2 todo)
Types: multi_dimensional_array.t
Parse Error: Statement not terminated properly
(10 skipped)
Null PMC access in find_method()
(9 todo)
Types: nan.t
Nominal type check failed for scalar store; got Num, needed Int or subtype
(1 skipped)
unspecced and inconsistent
(1 skipped)
Types: pair.t
eqv NYI for Pair
(1 skipped)
Invocant handling is NYI
(2 skipped)
setting .key changes original val!
(2 todo)
method($invocant:) syntax missing
(2 skipped)
should it really have \n on the end?
(1 todo)
Types: parcel.t
.item.perl on empty Parcel gives Match.ast shorthand
(1 todo)
Types: range.t
Unable to resolve method reverse in class Range
(2 skipped)
Attempted to access slot $!min of type object for Range
(1 skipped)
Undeclared name: "Failure"
(1 skipped)
Types: set.t
.grabpairs NYI
(1 skipped)
Hypers not yet Set compatible
(10 skipped)
.total/.minpairs/.maxpairs NYI
(8 skipped)
Unmatched key in Hash.LISTSTORE
(3 skipped)
Set in Set does not work correctly yet
(4 todo)
Losing type in Set
(1 todo)
Set is no longer Iterable
(1 skipped)
Odd number of elements
(3 skipped)
Not properly interpolating
(2 todo)
Hypers not yet Set compatible
(10 todo)
Types: sethash.t
is SetHash doesn't work yet
(10 skipped)
.grabpairs NYI
(18 skipped)
.total/.minpairs/.maxpairs NYI
(8 skipped)
Non-string keys NYI
(1 todo)
Failed test
41 - SetHash.kv returns list of keys and values
'is ObjectType' NYI
(10 skipped)
no longer Iterable
(1 skipped)
Not up to current spec
(2 todo)
Types: sigils-and-types.t
Undeclared name Buf
(1 skipped)
Undeclared name QuantHash
(1 skipped)
Methods must be used in some kind of package
(4 skipped)
Capture does Associative
(1 todo)
Capture does Positional
(1 todo)
Types: subset.t
Methods must be used in some kind of package
(1 skipped)
Exception NYI
(2 skipped)
(noauto) succeeds for the wrong reason (need to test the error)
(1 skipped)
Types: type.t
native types (noauto)
(6 skipped)
Trait of not available on variables
(2 skipped)
retrun value type checking NYI
(8 todo)
Types: undefined-types.t
.clone doesn't copy typedness
(4 todo)
Types: unicode.t
Bytes/Codes/Graphs NYI
(9 skipped)
Types: whatever.t
Undeclared routine
(1 skipped)
Unable to resolve method postcircumfix:<( )> in class Range
(1 skipped)
Cannot use value like WhateverCode as a number
(1 skipped)
currying plus meta ops
(5 skipped)
S03: Summary of Perl 6 Operators
Binding: arrays.t
binding of array elements works with splice (2)
(1 todo)
Binding: attributes.t
class attributes
(3 skipped)
Binding: hashes.t
without fudging 1 rakudo test, the whole file fails?
(1 skipped)
Binding: nested.t
is parcel - https://github.com/sorear/niecza/issues/177
(8 skipped)
Binding: scalars.t
difference of interpretation on ro binding
(2 todo)
Feeds: basic.t
double-ended feeds
(4 skipped)
feeds + signatures
(2 todo)
Junctions: autothreading.t
interferes hard with inlining
(1 skipped)
Junctions: boolean-context.t
Difficulties overloading | and &
(2 todo)
named unary as function call
(1 todo)
Junctions: misc.t
Impossible test: === takes Any
(4 skipped)
lower case junction
(4 skipped)
lower case junction type
(2 todo)
Metaops: cross.t
Unable to resolve method slice in class List
(1 skipped)
.slice for iterators NYI
(1 skipped)
Metaops: eager-hyper.t
hyper prefix NYI
(2 skipped)
Array assignment is not lazy -- is this test wrong?
(1 todo)
Metaops: hyper.t
203 tests aborted (missing ok/not ok)
(203 aborted)
Failed test
aborted 203 test(s)
nom regression: possible spec change/improvement
(2 skipped)
nom regression - whatever extension
(6 todo)
Metaops: reduce.t
this is parsed as ![=], not good
(2 skipped)
huh? these are macros
(2 skipped)
reduce is not supposed to flatten?
(1 skipped)
These are hyperop tests!
(1 todo)
this is parsed as ![=], not good
(2 todo)
unary [] does not context yet
(1 todo)
triangle [\^^] and [\xor]
(2 todo)
reduced hyper op
(1 todo)
Metaops: zip.t
Unable to resolve method munch in class List
(1 skipped)
Cannot use value like Whatever as a number
(2 skipped)
Unable to resolve method lol in type Parcel
(3 skipped)
nom regression
(2 skipped)
Operators: adverbial-modifiers.t
Multi colonpair syntax not yet understood
(5 skipped)
Multi colonpair syntax not yet understood
(1 todo)
Operators: also.t
Excess arguments to CORE seqop, used 3 of 4 positionals
(1 skipped)
Operators: arith.t
No agreement over correct behavior here -- above web page not helpful!
(1 todo)
Operators: assign.t
Buffer bitops NYI
(15 skipped)
Unable to resolve method LISTSTORE in class List
(2 skipped)
$a[] autovivification (unspecced?)
(1 skipped)
Overloading infix:<=> fails
(2 skipped)
assigning to ($a, *)
(1 todo)
expects a term, found infix >= instead
(3 skipped)
Two terms in a row
(3 skipped)
cannot modifiy an immutable value
(3 skipped)
Odd number of elements found where hash expected
(1 skipped)
list assignment to scalar
(5 todo)
list assignment, autovivification (?)
(3 todo)
list assignment with ($var, *)
(1 todo)
item/list assignment
(1 todo)
Operators: autoincrement-range.t
Magical string decrement underflowed
(14 skipped)
Magical string decrement underflowed
(1 todo)
Arabic-Indic NYI
(6 todo)
Operators: autoincrement.t
Operators: autovivification.t
Operators: bag.t
Reduction and bag operators
(16 skipped)
Operators: bit.t
string bitops
(11 skipped)
Operators: boolean-bitwise.t
No value for parameter $a in CORE infix:<?&>
(2 skipped)
No value for parameter $a in CORE infix:<?^>
(2 skipped)
No value for parameter $b in CORE infix:<?^>
(2 skipped)
No value for parameter $b in CORE infix:<?|>
(2 skipped)
No value for parameter $b in CORE infix:<?&>
(2 skipped)
No value for parameter $a in CORE infix:<?|>
(2 skipped)
Operators: context-forcers.t
Trait context not available on variables
(2 skipped)
Trait dynamic not available on variables
(2 skipped)
Unmatched key in Hash.LISTSTORE
(2 skipped)
https://github.com/sorear/niecza/issues/179
(1 todo)
failure modes of Str.Numeric
(2 skipped)
Operators: context.t
Invalid hard reference syntax
(1 skipped)
Excess arguments to item, used 1 of 2 positionals
(4 skipped)
Operators: equality.t
No value for parameter $r in CORE infix:<==>
(1 skipped)
No value for parameter $l in CORE infix:<!=>
(1 skipped)
No value for parameter $r in CORE infix:<!=>
(1 skipped)
No value for parameter $l in CORE infix:<==>
(1 skipped)
Operators: eqv.t
Cannot use value like Block as a number
(4 skipped)
Cannot use value like Capture as a number
(14 skipped)
Cannot use value like Sub as a number
(3 skipped)
Operators: flip-flop.t
dubious scoping?
(2 skipped)
Operators: increment.t
Works fine in niecza...
(1 todo)
Operators: inplace.t
sort is not a stable sort on all platforms
(2 todo)
Method '' not found for invocant of class 'Str'
(4 skipped)
Operators: is-divisible-by.t
not sure why this doesn't fire
(1 todo)
Operators: minmax.t
Annoying test that we haven't done the obvious yet unspecced, fails because we have indeed done the obvious
(2 todo)
max/min non-associative NYI
(2 todo)
Operators: nesting.t
undeclared name [+]
(2 skipped)
undeclared name [<=>]
(1 skipped)
undeclared name [==]
(1 skipped)
Operators: numeric-shift.t
shift by negative bit count
(12 skipped)
Operators: orelse.t
orelse sets $!
(1 skipped)
orelse passes $! as argument
(1 skipped)
orelse passes $! as multiple arguments
(1 skipped)
Operators: precedence.t
assigning to readonly value
(2 skipped)
nom regression
(2 skipped)
list associativity bug
(1 todo)
non-associativeness of infix:<^> and |
(2 todo)
Operators: range-basic.t
No exceptions
(8 skipped)
Operators: range.t
cannot increment a value of type Match
(3 skipped)
Spec under design here
(4 skipped)
Unhandled exception: cannot increment a value of type Array
(11 skipped)
forbid Ranges as Range endpoints
(1 todo)
Operators: reduce-le1arg.t
expected Any but got Mu instead
(1 skipped)
Operators: set.t
Reduction and set operators
(16 skipped)
Operators: short-circuit.t
wrong return type
(6 todo)
Operators: so.t
check test and rakudo
(1 todo)
Operators: subscript-adverbs.t
Excess arguments to KERNEL Hash.postcircumfix:<{ }>, unused named v
(6 skipped)
Excess arguments to KERNEL Array.postcircumfix:<[ ]>, unused named v
(18 skipped)
Cannot use value like Pair as a number
(2 todo)
Operators: value_equivalence.t
Failed test
33 - === on scalar references (1-3)
Failed test
55 - === on anonymous scalar references (2)
.WHICH based on type names
(1 todo)
\@a seems to flatten when it should not
(1 todo)
Sequence: arity-2-or-more.t
Undeclared names: '[%]'
(2 skipped)
Undeclared names: '[+]'
(1 skipped)
Sequence: arity0.t
Unable to resolve method munch in class List
(10 skipped)
Sequence: misc.t
Unable to resolve method chars in class Block
(1 skipped)
Cannot use value like Block as a number
(1 skipped)
Nominal type check failed in binding Int $n in f; got Str, needed Int
(1 skipped)
Slicel lists are NYI
(3 skipped)
Need something on the LHS
(1 skipped)
Slicel lists are NYI
(1 skipped)
Not enough positional parameters passed; got 0 but expected 1
(1 skipped)
gives True instead
(1 todo)
Sequence: nonnumeric.t
Two definitions found for symbol ::GLOBAL::&infix:<cmp> (etc)
(17 skipped)
munch not implemented
(3 skipped)
lifting comparison ops
(6 skipped)
Decrement out of range
(2 skipped)
Smartmatch: any-num.t
Nominal type check failed for #1
(2 skipped)
Mu ~~ Num doesn't work yet
(2 skipped)
Smartmatch: any-str.t
Mu as argument
(1 skipped)
smartmatching Mu against Str
(1 skipped)
Smartmatch: any-type.t
Unable to resolve method ACCEPTS in type M
(1 todo)
Smartmatch: array-array.t
Smartmatch: signature-signature.t
Parametric types
(1 skipped)
Code params with signatures
(1 skipped)
S04: Blocks and Statements
Blocks And Statements: let.t
'fail' used at line 68
(1 skipped)
let restore on exception, RT 121647
(1 todo)
Blocks And Statements: pointy-rw.t
Blocks And Statements: pointy.t
Could not find non-existent sub junction
(3 skipped)
Unable to resolve method name in class Sub
(1 todo)
pointy blocks and last/redo
(1 todo)
Blocks And Statements: temp.t
spec clarification needed
(15 skipped)
TEMP phasers NYI
(6 todo)
temp + recursion
(1 todo)
temp and recursion
(1 todo)
Declarations: constant.t
Lexical foo3 is not a package (?)
(3 skipped)
Cannot use COMPILING outside BEGIN scope
(3 skipped)
Undeclared name: 'G::c'
(2 skipped)
Cannot use bind operator with this LHS
(1 skipped)
Unable to resolve method postcircumfix:<( )> in class Int
(1 skipped)
unicode constant name
(1 skipped)
constants as type constraints
(1 todo)
Declarations: implicit-parameter.t
pointy blocks and $_
(2 todo)
Declarations: my.t
a not predeclared
(1 skipped)
nom regression, OUR::
(2 skipped)
Method 'submethod_table' not found
(1 skipped)
previous test skipped
(1 todo)
Declarations: our.t
our-scoped var in role
(1 todo)
Declarations: state.t
embedded closures in regexen
(1 todo)
initialization happens only on first call(?)
(1 todo)
Declarations: will.t
declared variable not visible in block yet
(2 skipped)
declared variable not visible in block yet# TODO will init NYI
(1 skipped)
declared variable not visible in block yet
(2 todo)
Exceptions: pending.t
$object.handled
(3 skipped)
not full of fail?
(1 todo)
Phasers: end.t
lexicals and EVAL()
(2 todo)
Phasers: enter-leave.t
dubious: noauto
(2 skipped)
unwind, RT 121530
(1 skipped)
is this spec? why would LEAVE not see outer $!? fossil?
(1 todo)
Phasers: first.t
2 tests aborted (missing ok/not ok)
(2 aborted)
Failed test
aborted 2 test(s)
Phasers: next.t
NEXT/LEAVE ordering
(2 todo)
Phasers: pre-post.t
POST and exceptions
(1 skipped)
POST and exceptions
(1 todo)
failing PRE block should not run any other phasers, RT 121531
(1 todo)
Phasers: rvalue.t
Excess arguments to EVAL, used 1 of 2 positionals
(1 skipped)
block returns no value
(6 todo)
Statement Modifiers: for.t
Statement Modifiers: if.t
empty list as element not flattened - https://github.com/sorear/niecza/issues/180
(1 todo)
Statement Modifiers: unless.t
empty list as element not flattened - https://github.com/sorear/niecza/issues/180
(1 todo)
Statements: do.t
last without loop construct
(1 skipped)
redo without loop construct
(1 skipped)
Undeclared name A
(3 skipped)
next without loop construct
(1 skipped)
Statements: for.t
slice context
(1 skipped)
array iterator does not track a growing array
(2 todo)
https://github.com/sorear/niecza/issues/180
(1 todo)
optional variable in for loop (RT #63994)
(1 skipped)
maybe bogus, for loops are not supposed to be lazy?
(1 skipped)
RT 113026 array iterator does not track a growing array
(2 todo)
Statements: gather.t
Cannot use bind operator with this LHS
(5 skipped)
RT #117635 (infinite loop)
(1 skipped)
Statements: repeat.t
No value in ANON available for parameter $a
(1 skipped)
Statements: try.t
new exception stuff
(5 skipped)
=== and Nil NYI
(2 skipped)
Method 'substr' not found
(1 skipped)
S05: Regexes and Rules
Capture: caps.t
conjunctive regex terms - nyi
(12 skipped)
RT117995 - quantified conjunctive capture
(1 todo)
Capture: match-object.t
No such method pos for invocant of type Any
(1 skipped)
Unsupported use of $¢ variable
(1 skipped)
Unsupported use of $¢ variable
(1 todo)
Capture: named.t
Writing to readonly scalar
(2 skipped)
assigning to match object
(2 skipped)
Grammar: action-stubs.t
Failed test
19 - $/ availiable
Grammar: inheritance.t
Cannot dispatch to a method on Baz because it is not inherited or done by Cursor
(6 skipped)
Cannot dispatch to a method on Foo because it is not inherited or done by Cursor
(1 skipped)
Cannot dispatch to a method on Bar because it is not inherited or done by Cursor
(4 skipped)
automatic Grammar superclass
(1 todo)
Grammar: methods.t
Failed test
6 - duplicate methods err sanely
Grammar: namespace.t
Cannot dispatch to a method on GrammarShallow because it is not inherited or done by Cursor
(1 skipped)
Grammar: parse_and_parsefile.t
11 tests aborted (missing ok/not ok)
(11 aborted)
Failed test
aborted 11 test(s)
Grammar: protoregex.t
30 tests aborted (missing ok/not ok)
(30 aborted)
Failed test
aborted 30 test(s)
Grammar: ws.t
infinite loop: RT #64094 (noauto)
(2 skipped)
Interpolation: regex-in-variable.t
Object reference not set to an instance of an object
(2 skipped)
Representation P6cursor does not support attributes
(3 skipped)
Cannot cast from source type to destination type.
(1 skipped)
instance member interpolation
(3 skipped)
Mass: charsets.t
Unicode 6.3 -- lower characters
(1 todo)
Unicode 6.3 -- punct characters
(2 todo)
unicode 6.0 punct characters
(1 todo)
blank characters
(1 todo)
punct characters
(1 todo)
Mass: named-chars.t
CR as char name
(2 skipped)
negative char class in enumerated list
(62 skipped)
NEL as char name
(2 skipped)
FF as char name
(2 skipped)
\c[LF] not valid charname
(4 skipped)
\c[CR] not valid charname
(4 skipped)
escapes in char classes
(5 skipped)
\c[NEL] not valid charname
(7 skipped)
\c[FF] not valid charname
(4 skipped)
LF as char name
(2 skipped)
Mass: properties-derived.t
isCommon not implemented
(10 skipped)
isGraphemeLink
(7 skipped)
isAssigned not implemented
(7 skipped)
isAny not implemented
(4 skipped)
isOther* not implemented
(35 skipped)
isUnassigned not implemented
(1 todo)
isOther* not implemented
(42 skipped)
Mass: properties-general.t
No [Lr] property defined
(10 skipped)
Invalid codepoint \x[FFFE]
(16 skipped)
Invalid codepoint \x[FFFF]
(4 skipped)
Unicode spec change in v6.1
(3 todo)
Unions of properties of non-existent codepoints
(4 todo)
Unicode spec change in v6.1
(6 todo)
Mass: properties-script.t
Unicode properties with arguments
(35 skipped)
Mass: rx.t
Unable to resolve method alpha in class Cursor
(1 skipped)
Dubious test, http://irclog.perlgeek.de/perl6/2012-05-27#i_5643089
(2 skipped)
Unable to resolve method wb in class Cursor
(13 skipped)
Autoloading NYI
(1 skipped)
Action method mod_arg not yet implemented
(21 skipped)
Unable to resolve method name in class Cursor
(2 skipped)
space between - and [ ] is a problem?
(1 skipped)
Unsuppored elements in after list
(4 skipped)
undefined capture
(1 todo)
Failed test
424 - sigspace (:s)
Failed test
425 - sigspace (:s)
Failed test
429 - sigspace (:s)
Failed test
434 - sigspace (:sigspace)
Failed test
437 - sigspace (:sigspace)
<commit> not implemented
(1 skipped)
closure repetition
(1 skipped)
regex <name>
(2 skipped)
anchors and after
(1 todo)
Match: blocks.t
Assignment to matched string affects earlier match objects
(1 todo)
Match: capturing-contexts.t
rule declaration outside of grammar
(2 skipped)
No value for parameter $obj in isa_ok
(1 skipped)
match with non-existent capture does not match
(1 todo)
Match object in $/ after match in void context
(1 todo)
binding to $/
(5 skipped)
Match: perl.t
No value for parameter $a in is_deeply
(1 skipped)
Cannot dispatch to a method on GLOBAL::Perl6::Grammar
(4 skipped)
Metachars: closure.t
assigning to readonly value
(5 skipped)
make() inside closure
(3 skipped)
assignment to match variables (dubious)
(5 skipped)
Metachars: tilde.t
Unable to resolve method FAILGOAL in class Cursor
(11 skipped)
backtracking to find ~ goal
(2 skipped)
exceptions from regexes
(3 skipped)
backtracking into ~
(2 skipped)
should not throw exceptions
(5 skipped)
Metasyntax: angle-brackets.t
Action method assertion:sym<*> not yet implemented
(11 skipped)
Anonymous submatch returned a Str instead of a Cursor, violating the submatch protocol
(1 skipped)
Action method assertion:sym<~~>
(2 skipped)
Sigil % is not allowed for regex assertions
(2 skipped)
Action method assertion:sym<???> not yet implemented
(3 skipped)
Unable to resolve method test in class Cursor
(5 skipped)
<.$foo> syntax placeholder
(1 todo)
string value was cached
(1 todo)
indirect subrule call not implemented
(1 skipped)
<test()> not implemented
(2 skipped)
<$subrule> not implemented
(2 skipped)
colon arguments not implemented
(1 skipped)
<*literal>
(11 skipped)
<&foo()> not implemented
(1 skipped)
angle quotes in regexes
(2 skipped)
<%hash> not implemented
(2 todo)
Metasyntax: charset.t
large \x char spec in regex (RT #67122) (noauto)
(1 skipped)
Metasyntax: delimiters.t
* not yet supported
(1 todo)
? not yet supported
(1 todo)
~ not yet supported
(1 todo)
+ not yet supported
(1 todo)
Metasyntax: interpolating-closure.t
Metasyntax: litvar.t
sequential semantics NYI
(1 todo)
Metasyntax: longest-alternative.t
Regex modifier g not yet implemented
(7 skipped)
LTM - literals in tokens
(1 todo)
LTM - longer quantified atom wins against shorter literal (subrules)
(1 todo)
LTM - literals in nested tokens
(1 todo)
implicit <.ws> stops LTM
(1 todo)
LTM only participated up to the LTM stopper :::
(1 todo)
LTM - literals in tokens
(2 todo)
Metasyntax: regex.t
Exception NYI
(2 skipped)
Metasyntax: repeat.t
closure repetition
(6 skipped)
Metasyntax: sequential-alternation.t
sequential alternation NYI
(2 todo)
Modifier: counted-match.t
Excess arguments to CORE Cool.match
(4 skipped)
Modifier: counted.t
https://github.com/sorear/niecza/issues/186
(1 todo)
Modifier: ignorecase.t
ignorecase and SS/ß
(2 todo)
Modifier: overlapping.t
m:overlap// NYI
(5 skipped)
Modifier: perl5_5.t
(?i) and backreferences
(2 todo)
Modifier: perl5_8.t
character classes in enumerated range
(6 skipped)
expensive quantifier
(18 skipped)
(?>...) not implemented
(1 todo)
Modifier: sigspace.t
Failed test
10 - inline :s doesn't imply <.ws> immediately (-)
Failed test
13 - Semantics of sigspace after ^
Substitution: subst.t
Action method quote:ss not yet implemented
(3 skipped)
s[...] op= RHS
(3 skipped)
Unable to resolve method postcircumfix:<( )> in type Any
(3 skipped)
Regex modifiers ii and samecase NYI
(2 skipped)
:samecase NYI
(8 skipped)
Cannot assign to $/
(10 skipped)
Niecza works when it shouldn't?
(1 todo)
be smarter about constant detection
(1 todo)
Transliteration: trans.t
closures and regexes
(2 skipped)
Nominal type check failed for scalar store; got Int, needed Str or subtype
(2 skipped)
Action method quote:tr not yet implemented
(5 skipped)
trans flags NYI
(11 skipped)
Not sure what is supposed to be going on here
(1 todo)
tr///, feed operator not implemented
(5 skipped)
disambiguate ranges
(1 todo)
Transliteration: with-closure.t
Unable to resolve method ord in class Any
(1 skipped)
Closure invoked twice
(1 todo)
regex and closure mix (with $/ as topic)
(1 todo)
Closure executed three times
(1 todo)
regex and closure mix (with $/ as topic and capture)
(1 todo)
can use closures in pairs
(1 todo)
S06: Subroutines
Advanced: caller.t
try interferes with caller counting
(1 todo)
Advanced: callframe.t
Unable to resolve method inline in type CallFrame
(1 skipped)
Unable to resolve method my in type CallFrame
(2 skipped)
Advanced: lexical-subs.t
cannot parse operator names yet
(2 skipped)
Advanced: return.t
Excess arguments to return, unused named c
(3 skipped)
Advanced: wrap.t
control operator crossed continuation barrier
(1 skipped)
RT 70267: call to nextsame with nowhere to go
(1 todo)
Currying: assuming-and-mmd.t
Unable to resolve method assuming in class Code
(2 skipped)
Currying: mixed.t
Unable to resolve method assuming:x<XXX> in class Sub
(2 skipped)
Multi colonpair syntax not yet understood
(1 skipped)
Macros: opaque-ast.t
:COMPILING flag
(3 skipped)
return from macro
(1 skipped)
Macros: quasi-blocks.t
Method 'succ' not found
(2 skipped)
No such method 'STORE' for invocant of type 'Mu'
(2 skipped)
Macros: unquoting.t
Specified code ref has no outer, RT 121533
(1 skipped)
Multi: by-trait.t
Ambiguous dispatch for &uno_mas
(1 skipped)
Multi: lexical-multis.t
lexical scope as tie breaker
(1 todo)
Multi: positional-vs-named.t
slurpy and named interaction
(2 skipped)
Multi: proto.t
Unhandled exception: Cannot use value like Block as a number
(8 skipped)
>>>Stub code executed
(1 skipped)
System.NullReferenceException: Object reference not set to an instance of an object
(1 skipped)
Illegal redeclaration of routine 'bar'
(5 skipped)
redeclaration of routine 'bar'
(5 skipped)
Multi: syntax.t
Ambiguous dispatch for &bar
(2 skipped)
No candidates for dispatch to &bar
(1 skipped)
Ambiguous dispatch for &baz
(1 skipped)
No candidates for dispatch to &baz
(1 skipped)
Ambiguous call to &rt68528
(1 skipped)
Multi: type-based.t
Two definitions found for symbol ::GLOBAL::A::&a
(3 skipped)
two or more Anys error
(4 skipped)
We turned these off because of a niecza bug
(2 skipped)
Ambiguous dispatch for &f4
(6 skipped)
Ambiguous dispatch for &f2
(1 skipped)
no native types yet
(1 skipped)
GLOBAL::T does not name any package
(12 skipped)
$*ERR is apparently not IO
(1 skipped)
our sub in class
(3 skipped)
Operator Overloading: methods.t
I think niecza may be doing this correctly, but it's hidden in other warnings
(1 todo)
Operator Overloading: sub.t
Undeclared routine
(1 skipped)
Cannot use hash access on an object of type Array
(1 skipped)
No matching candidates to dispatch for &infix:<+>
(2 skipped)
Unhandled exception: Malformed block at (eval) line 1
(2 skipped)
... was hyperized
(1 todo)
... with hyperization
(1 todo)
... basic infix operator overloading worked
(1 todo)
stringification didn't die
(1 todo)
... worked in array stringification
(1 todo)
missing block, apparently "if" not an op
(1 skipped)
not yet implemented
(2 skipped)
infix Z will never work; no lexical Z
(1 skipped)
missing block, no lexical Z
(4 skipped)
prefix:[] form not implemented
(4 skipped)
undeclared name
(1 skipped)
cannot bind with this LHS
(1 skipped)
Other: anon-hashes-vs-blocks.t
Thinks the block is a hash
(3 skipped)
Other: main-usage.t
copied nom regression
(5 todo)
Other: misc.t
maximum recursion depth exceeded
(2 skipped)
hangs, probably due to [RT #114134]
(1 skipped)
Routine Modifiers: lvalue-subroutines.t
Signature: closure-parameters.t
type syntax parse failure
(11 skipped)
Signature: introspection.t
Abbreviated named parameter must have a name
(1 skipped)
Unable to resolve method constraints in class Parameter
(5 skipped)
Unhandled trait rwt
(10 skipped)
Parameter separator ; NYI
(3 skipped)
Action method fakesignature not yet implemented
(6 skipped)
GLOBAL::T does not name any package
(2 skipped)
Does this test make sense?
(1 todo)
expected Any but got Mu instead
(1 skipped)
Signature: named-parameters.t
Abbreviated named parameter must have a name
(1 skipped)
multiple same-named arguments NYI
(16 skipped)
Unhandled trait required
(2 skipped)
Renaming a parameter to an existing positional should fail
(1 todo)
sub params with the same name
(2 todo)
where constraints
(4 skipped)
Not enough positional parameters passed; got 0 but expected 1
(1 skipped)
Signature: slurpy-and-interpolation.t
Unable to resolve method Capture in type Range
(1 skipped)
Signature: slurpy-params.t
Unhandled trait of
(11 skipped)
Unhandled trait required
(2 skipped)
*$f slurps everything up
(3 todo)
Types on slurpy params are checked
(1 todo)
types on slurpy params
(17 skipped)
Signature: sub-ref.t
macros, compile time binding
(4 skipped)
Signature: tree-node-parameters.t
signature binding of return values NYI
(4 skipped)
Signature: type-capture.t
nom regression
(1 skipped)
Signature: unpack-array.t
https://github.com/sorear/niecza/issues/180
(2 todo)
Signature: unspecified.t
RT 71112: Cannot assign to readonly variable.
(1 todo)
Traits: is-readonly.t
readonly attributes
(1 todo)
Traits: is-rw.t
Depends on preceding test working
(1 todo)
Traits: misc.t
is readonly does not override
(2 todo)
Traits: precedence.t
changing precedence of already declared op
(1 todo)
S12: Objects
Attributes: augment-and-initialization.t
Unable to resolve method t in class T1
(2 skipped)
Attributes: class.t
Two definitions of method b
(2 skipped)
nom regression - method ^foo
(6 skipped)
Attributes: clone.t
Exception: Representation P6cursor does not support cloning
(2 todo)
clone currently messes up original
(2 todo)
Attributes: defaults.t
'self' used where no object is available
(2 skipped)
Attributes: instance.t
Unable to resolve method of in class Array
(1 skipped)
Unhandled parameter twigil .
(2 skipped)
Attribute $!x declared outside of any class
(1 skipped)
Unable to resolve method of in class Hash
(1 skipped)
Variable $.a used where no self is available
(3 skipped)
original not affected
(2 todo)
ro array/hash with accessor
(2 todo)
ro on list attributes
(2 todo)
dubious test - the initializer becomes a submethod here, implying a scope
(1 skipped)
over-eager auto-vivification bugs
(1 todo)
Attributes: mutators.t
Can not get attribute $!varies declared in class MagicVal with this object
(7 skipped)
Attributes: recursive.t
A type must be provided ???
(8 skipped)
https://github.com/sorear/niecza/issues/183
(2 todo)
Class: anonymous.t
Anonymous class stringification (?)
(1 todo)
Class: attributes.t
Unhandled exception: Unable to resolve method ctxzyg in type Method
(1 skipped)
Unhandled parameter twigil !
(6 skipped)
$b declared but not used. FIXME later.
(1 skipped)
Cannot use .= to initialize an attribute
(1 skipped)
Class: augment-supersede.t
redeclaration of symbol Bar
(2 skipped)
Class: basic.t
No value for parameter \$expected in Test is
(3 skipped)
Methods must be used in some kind of package
(1 skipped)
Exception: Unable to resolve method add_method in type ClassHOW
(1 todo)
Calling is will never work with argument types (Foo)
(3 skipped)
Class: inheritance.t
Unable to resolve method parents in class ClassHOW
(1 skipped)
Pathed definitions require our scope
(2 skipped)
Class: instantiate.t
Exception NYI
(2 skipped)
Class: namespaced.t
Cannot dispatch to a method on D because it is not inherited or done by Cursor
(2 skipped)
Class: stubs.t
broken in nom-derived stub model
(1 todo)
Construction: BUILD.t
method BUILD should warn
(1 todo)
Construction: autopairs.t
Construction: construction.t
System.NullReferenceException: Object reference not set to an instance of an object
(2 skipped)
Malformed has (int NYI, I think)
(3 skipped)
Construction: new.t
Without previous line, this is a disaster
(1 skipped)
dies more thoroughly than okay
(1 skipped)
Cannot call new; none of these signatures match
(1 skipped)
No candidates for dispatch to new
(1 skipped)
parent attributes in initialization
(9 todo)
nested package handling does't quite get this one right
(1 todo)
Enums: basic.t
Enum must have at least one value
(1 skipped)
Enum must have at least one value
(1 todo)
Cannot convert string to number
(5 skipped)
Enums: misc.t
No value for parameter $key in CORE CommonEnum.postcircumfix:<( )>
(1 skipped)
Enums: thorough.t
does &day::("Tue")
(16 skipped)
does day::Tue
(2 skipped)
Introspection: WHAT.t
no typed support
(24 skipped)
of Type on scalars fails
(3 todo)
Foo[Int].new on scalars fails
(4 todo)
Foo[Int,Str].new on scalars fails
(1 todo)
looks like a type object, but is not
(2 todo)
%h{Str} of Int fails
(2 todo)
Introspection: attributes.t
:tree not implemented for .^attributes
(5 skipped)
Introspection: can.t
.can returns something Positional
(1 todo)
Introspection: meta-class.t
.version, version number parsing
(1 skipped)
precedence of prefix:<^>
(1 skipped)
precedence of HOW
(1 skipped)
Introspection: methods.t
nom regression
(11 skipped)
Introspection: roles.t
.^roles(:tree)
(4 skipped)
Methods: calling_sets.t
ambiguous dispatch
(11 skipped)
Methods: class-and-instance.t
https://github.com/sorear/niecza/issues/185
(2 todo)
Methods: defer-next.t
variant of RT 69608
(1 todo)
Methods: indirect_notation.t
Two definitions found for symbol ::GLOBAL::T4::&m, etc
(15 skipped)
Invocant handling is NYI
(2 skipped)
Unable to resolve method postcircumfix:<( )> in class Array
(6 skipped)
.@foo not yet working
(6 skipped)
.*, .+ and .? with @foo
(15 skipped)
TTIAR near $o:
(2 skipped)
Methods: instance.t
indirect object notation
(2 skipped)
Methods: method-vs-sub.t
Invocant handling is NYI
(1 skipped)
confused near "($obj:), "
(1 skipped)
Methods: multi.t
No candidates for dispatch to C.foo
(2 skipped)
NYI dottyop form .*
(3 skipped)
Exception NYI
(1 skipped)
depends on previous test
(1 todo)
This test is pretty dubious IMO
(1 todo)
proto does not promote to multi
(2 skipped)
Methods: parallel-dispatch.t
NYI dottyop form
(11 skipped)
Cannot use hash access on an object of type Pair
(1 skipped)
No such method postcircumfix:<( )> for invocant of type Pair
(1 skipped)
is_deeply does not think map results are the same as list on LHS
(5 todo)
Methods: private.t
7 tests aborted (missing ok/not ok)
(7 aborted)
Failed test
aborted 7 test(s)
Methods: submethods.t
outer lexicals in roles
(2 skipped)
roles and submethods
(4 skipped)
Methods: syntax.t
Excess arguments to Any.map, used 2 of 4 positionals
(1 skipped)
Interaction between semiargs and args is not understood
(3 skipped)
switch-from-paren-to-listop form
(3 skipped)
adverbial closures
(1 skipped)
Methods: topic.t
Failed test
1 - $_ is not set in methods...
Subset: subtypes.t
Object reference not set to an instance of an object
(6 skipped)
Exceptions not supported
(1 skipped)
$n has already been used as a non-placeholder in the surrounding block
(3 skipped)
Pathed definitions require our scope
(4 skipped)
S29: Distributions, Recommendations, Delivery and Installation
Context: die.t
test needs rewriting, EVAL does not catch exceptions
(2 skipped)
Context: eval.t
method form of EVAL does not see outer lexicals
(1 skipped)
Unable to resolve method encode in class Str
(1 skipped)
No :lang argument yet...
(1 todo)
EVAL coerce to string
(2 skipped)
Context: exit.t
Failed test
2 - exit 5; works
Failed test
3 - try-block does not catch exit exceptions
Conversions: ord_and_chr.t
chr handling of invalid code-points
(5 skipped)
multi-arg variants of chr not in place yet
(1 skipped)
high character name lookup
(1 skipped)
RT #65172 - combining graphemes
(1 todo)
chr of noncharacter
(2 todo)
Os: system.t
run() broken (and test questionable
(1 skipped)
depends on rakudo being installed
(1 todo)


Interactive-Book
Learn Digital Logic Design easily.
Computer Logical Organization refers to the level of abstraction above the digital logic level, but below the operating system level. At this level, the major components are functional units or subsystems that correspond to specific pieces of hardware built from the lower level building blocks.
This interactive book gives a complete understanding on Computer Logical Organization starting from basic computer overview till its advanced architecture. It is meant to provide the readers to know how to analyze and implement the combinational circuits and sequential circuits. Based on the requirement, we can use either combinational circuit or sequential circuit or combination of both. After completing this book, you will be able to learn the type of digital circuit, which is suitable for specific application.
Audience
This reference has been prepared for the students pursing either Bachelors or Masters in Computer Science/Electronics to help them understand the basic-to-advanced concepts related to Computer Logical Organization.It is also meant for thosewho are aspiring to learn the concepts of digital circuits. Digital circuits contain a set of Logic gates and these can be operated with binary values, 0 and 1.
Prerequisites
Before you start proceeding with this Book, I’m making an assumption that you are already aware of basic computer concepts like what is keyboard, mouse, monitor, input, output, primary memory, secondary memory, etc. A basic idea regarding the initial concepts of Digital Electronics is enough to understand the topics covered in this tutorial.
About the project
Interactive-Book is © 2019 by Aman Singla.


March eyed for start of hospital build
by Guy WilliamsThe developer of an independent surgical hospital next to the Queenstown Country Club hopes to start construction in March.
Sanderson Group chairman Fraser Sanderson says he hopes a resource consent variation to build the $20 million facility, filed in August, will be approved by the end of the year.
The project was at the final design stage, and working drawings were being produced.
“Everyone’s working flat out on it at the moment.
“We’re very confident. The mayor, the council and the community want this hospital … it’ll be an amazing facility.”
The single-level hospital will be built just south of the retirement village, overlooking Shotover Country, on a site originally consented for the village’s gym and swimming pool.
When it’s completed – expected to be in late 2021 – Sanderson Group will lease the hospital to joint venture partners Southern Cross Hospitals and Central Lakes Trust.
Southern Cross will manage the facility, and offer elective surgical procedures expected to include endoscopy, general surgery, gynaecology, dental, orthopaedic, urology, plastic surgery and ear, nose and throat.
Meanwhile, a group of bigwigs led by Health Minister David Clark turned up for tea and cakes at the official opening of the $9.3m upgrade of Lakes District Hospital last Friday.
The long-awaited upgrade means the public hospital now boasts a new emergency department, CT scanner, waiting area, triage and consulting areas, a medical students’ training room, plaster bay and decontamination area, as well as new heating and cooling systems.


This class contains the names of the phonemes that make up the words in the lexicon.
Inheritance:
Public Methods
-
PhoneInfo()
- Creates an empty PhoneInfo instance
-
char* getPhone( int index )
- Returns a pointer to the phoneme name at position "index" in the list
Public Members
-
Reads the phone information from 'phones_fname' file.
-
Looks at the first line of the file.
-
If it is "PHONE" then the file is assumed to be in Noway phone models format.
-
If it is "~o" then the file is assumed to be in HTK model definition format
-
Otherwise the file is assumed to contain just a straight list of phone names
-
If the sil_name and pause_name params are set, then the indices of the
-
Adds a phoneme to the end of the list of phonemes
-
is_sil and is_pause indicate if the phoneme is one of the special phonemes
-
Does a linear search through the list and returns the index of the
-
phoneme name supplied as a parameter
Inherited from Object:
Public Fields
-
Allocator* allocator
Public Methods
-
void addOption(const char* name, int size, void* ptr, const char* help="")
-
void addIOption(const char* name, int* ptr, int init_value, const char* help="")
-
void addROption(const char* name, real* ptr, real init_value, const char* help="")
-
void addBOption(const char* name, bool* ptr, bool init_value, const char* help="")
-
void addOOption(const char* name, Object** ptr, Object* init_value, const char* help="")
-
void setOption(const char* name, void* ptr)
-
void setIOption(const char* name, int option)
-
void setROption(const char* name, real option)
-
void setBOption(const char* name, bool option)
-
void setOOption(const char* name, Object* option)
-
virtual void loadXFile(XFile* file)
-
virtual void saveXFile(XFile* file)
-
void load(const char* filename)
-
void save(const char* filename)
-
void* operator new(size_t size, Allocator* allocator_=NULL)
-
void* operator new(size_t size, Allocator* allocator_, void* ptr_)
-
void operator delete(void* ptr)
Documentation
This class contains the names of the phonemes that make up
the words in the lexicon. An empty instance can be created,
and then phones added manually using the addPhone method,
or a filename can be specified containing phone information.
The list of phone names is then extracted automatically
from the file.
- PhoneInfo()
- Creates an empty PhoneInfo instance
- Reads the phone information from 'phones_fname' file.
- Reads the phone information from 'phones_fname' file.
- Looks at the first line of the file.
- Looks at the first line of the file.
- If it is "PHONE" then the file is assumed to be in Noway phone models format.
- If it is "PHONE" then the file is assumed to be in Noway phone models format.
- If it is "~o" then the file is assumed to be in HTK model definition format
- If it is "~o" then the file is assumed to be in HTK model definition format
- Otherwise the file is assumed to contain just a straight list of phone names
- Otherwise the file is assumed to contain just a straight list of phone names
- If the sil_name and pause_name params are set, then the indices of the
- If the sil_name and pause_name params are set, then the indices of the
- Adds a phoneme to the end of the list of phonemes
- Adds a phoneme to the end of the list of phonemes
- is_sil and is_pause indicate if the phoneme is one of the special phonemes
- is_sil and is_pause indicate if the phoneme is one of the special phonemes
- char* getPhone( int index )
- Returns a pointer to the phoneme name at position "index" in the list
- Does a linear search through the list and returns the index of the
- Does a linear search through the list and returns the index of the
- phoneme name supplied as a parameter
- phoneme name supplied as a parameter
- This class has no child classes.
- Author:
- Darren Moore<EMAIL_ADDRESS>Alphabetic index HTML hierarchy of classes or Java
This page was generated with the help of DOC++.


|
Heart Rate Monitor |
|
|
Table of Contents |
Alex Vassallo - Dec 2015 |
|
This project was created as a final project for CSE 466 Embedded System class at the University of Washington. The goal of the assignment was to detect the QRS complex of a heartbeat, display it to the screen, and write it to the SD card. The class was provided a Teensy 3.1 micro-controller and a schematic for a front end circuit used to capture and amplify the differential voltage across a pair of electrode leads. When the circuit was originally built and tested it performed very poorly due to excessive noise. Prior experience with signal conditioning led me to find circuit changes which allowed superior performance. The software design included additional digital filtering, heartbeat detectors, options menu, and a calibrated display of the data including calculated heartbeat characteristics.
Figure 1: Amplifier Schematic
Modification 1:
The amount of noise around 60Hz was extremely high. For this project, we only wanted signals up to about 10Hz. To help with this, I added two low pass filters shown in Blue within Figure 1. An active low pass filter was created by adding C8 to the final op-amp feedback path. This can be done since it outputs directly into a high impedance input on the micro-controller. The 2nd low pass filter was created by adding R18 and C9 to the previous output. Using the equation 1/(2*Pi*R*C), I was able to calculate the proper R and C values to achieve a -3db roll off frequency around 15Hz to attenuate the signal.
Modification 2:
When the electrodes are not being contacted by anything, the amount of ambient noise across them is enough to trigger the rhythm detector. To resolve this undesired effect, a 1 Mega-ohm resistor was placed across the inputs of the instrumentation amplifier. However, this reduced the amplitude of the signal, so the value of R8 was lowered to restore the previous gain level.
Modification 3:
The IC chips used were the BB INA128U Low-Power Instrumentation Amplifier and the Microchip MCP6004 Quad Low-Power Op-amp. Upon review of their datasheets, it was discovered that those parts performed much better at 5V instead of 3.3V, so the source voltage was moved to the 5V USB supply.
Figure 2: Schematic
In my design, I used the onboard Programmable Delay Block (PDB) as a timer source for capturing data. The PDB triggered the Analog to Digital Converter (ADC) to capture a data point, and upon ADC conversion completion, the ADC triggered the Direct Memory Access (DMA) to copy that 16 bit value directly into our array. The DMA was setup to trigger a software interrupt when 200 points of data has been captured, which is when we rotate our array indexes to perform different steps of operations. This allows each main loop in software sufficient time to perform calculations or interact with peripherals. As Figure 3 indicates, the DMA target is pointed to overwrite the oldest block of data, the Digital Filter is pointed at the sample that DMA has just completed filling, and the Rhythm Detector is pointed at the block of data that the filter has just processed. The blank block is necessary to preserve data that may be needed when capturing a complete heartbeat rhythm into an array.
Figure3: Data Flow
If an 'R' peak is detected within a sample block, the arrays are scanned backwards 119 points of data, and forward 200 points of data to capture the entire rhythm into a known format, The rhythm is copied into a new array of length 320, with the R peak aligned at position 120, where it can be stacked with other confirmed heartbeat rhythms for further analysis over time.
Figure 4: Rhythm Collection
The digital filter is a simple design which uses the average slope to determine which direction the line is heading. By excluding the point that we are attempting to modify, any large noise that the single point produces is not included in the calculation. This results in a very smooth line that we can use for finding the derivative of the data plot.
Figure 5: Digital Filter
During the filter stage, the calculated slopes are stored as an additional element in the array. A bitmap is also created where a 0 is stored normally, but a 1 is stored if the slope transitions from positive to negative, or negative to positive. This captures all of our points of interest in the potential heartbeat rhythm, and no calculations are required from this point forward. When attempting to pass a segment of data through our heartbeat detection, we can quickly scan our bitmap to find the associated values of data.
To locate a heartbeat, we scan our bitmap for the first value of 1, and assign it as point T in our rhythm. We then go backwards through the data samples, assigning P,Q,R, and S to the previous points of interest by using the associated bitmaps. If the group of points does not meet the requirements, then we slide all of our points over to the next point of interest and check again. This is very simple to do since we can assign P=Q, Q=R, R=S, S=T, and T= the next point. In parallel with this operation, we are also calculating the area under the curve between each point in our derivative data. Since our data has a finite amount of points, this is accomplished by simply summing up the derivate values as we progress across, and carrying through those values when we assign P=Q, Q=R, etc.
For the detection algorithm, I used a simple algorithm. Using the derivate data we check for the following:
|
Figure 6: Rhythm Detection |
1. The area under the curve between points Q to R is above the limit. 2. The negative area under the curve from R to S is above the limit. 3. The value of Point Q is roughly the average value of the data. 4. The distance between points Q and S is within the human limits. If so, we capture it as a rhythm and use point R as our zero point. Then to locate points P and T, we first check the bitmap for those points, and if they are not a great enough distance from the QRS complex, we move along the bitmap until we find a point that is within the bounds expected of the human heart. |
|
The Graphical User Interface displays a heartbeat trace grid, captured rhythm area, status information, and an optional menu. The heartbeat trace has been calibrated to the specification of 1 vertical line per 1 mV and 1 horizontal line per 40 ms, which is maintained as it automatically zooms in and out. The bpm is calculated from averaging only concurrent rhythms. Any detected heart conditions are displayed inside of the trace grid. |
|
|
|
Menu Record Data (30 Sec): Selecting "Record Data" will attempt to record 30 seconds of heartbeat data onto the SD card. It will only record while a valid rhythm is detected. Selecting "Stop Recording" from the menu before 30 seconds will close the recording session and save the data collected. Display Data from SD: When selecting "Display Data" from the menu, the software will open each file on the SD card sequentially and display a full screen of data at a time. Pressing the "select" button will cycle through the next screen of data, until all files have been read. Selecting "Live Data" from the menu will switch out of this mode and back to displaying live data. Erase SD card: This feature will erase all files on the SD card. Format SD card: This feature will format the installed SD Card with a FAT32 format. |


Try this Angular File Manager's Integration with a popular Open Source WYSIWYG Editor CKEditor. For more details refer the official page at https://ckeditor.com/ckeditor-4/


Community Of Developers
DevFlair aims to connect developers from different backgrounds so that they can collaborate on their ideas and learn together.
Join NowDevFlair aims to connect developers from different backgrounds so that they can collaborate on their ideas and learn together.
Join NowCopyright 2021 DevFlair


Whenever we want to use a value that is not readily available yet – for example, when we
call a function to compute or fetch something over the network –
we can not be sure if things go as were planned.
What if the database connection is down? What if the user typed in an invalid string?
Looping over a collection of items and transforming the individual elements
within is quite a common task. So it seems natural that Scala offers a nice
way to solve this.
Whenever we want to use a value that is not readily available yet – for example, when we
call a function to compute or fetch something over the network –
we can not be sure if things go as were planned.
What if the database connection is down? What if the user typed in an invalid string?
After Lists and tuples, let’s have a look at Maps.
They are sometimes called “hashtables”, “hashes”, or “dictionaries” in other programming languages.
Maps are a bit more complex than what we’ve seen before. They come handy
when you need to store associated pairs of data, or when
you need to easily look up a value corresponding to another value (which we will call the key).
In the following couple of posts we’ll learn about basic data structures,
and how they can be used in Scala.
Lists are what their name suggests: they can keep a list of things. The order
of its elements will be kept,
and a list does not care if an element appears more than once in it (which means it will not remove duplicates).
This is a more ‘practical’ topic, and I’m sure that many would argue
that learning how to use a unit testing framework is not strictly necessary
for newcomers. But according to my experience, getting into the
habit of writing tests regularly quickly pays off.
Pattern matching is a quite commonly used “programming pattern” in functional languages, because it
fits nicely into the “functional way of thinking”, and it is quite powerful and handy as a tool.
Generally in programming, enumerations (a.k.a. enums)
are light-weight means to create a very simple model within our code, for
representing a custom type with a limited set of possible values with readable
names.
This description might sound a bit too abstract, so
let’s see an example instead.
You’re probably here because you’ve heard that Scala is a cool programming language
and you’d like to learn more about it. Because, hey, it’s object-oriented and functional at the same time!
I’ll show you something very basic at first: a bit more “personal” version
of the famous
“Hello World” program.


Dashboard
Well done!
Aww yeah, you successfully read this important alert message. This example text is going to run a bit longer so that you can see how spacing within an alert works with this kind of content.
“You can’t connect the dots looking forward; you can only connect them looking backward. So you have to trust that the dots will somehow connect in your future.”


If you continue to see this message after a couple of seconds something has gone wrong. In order to run properly the experiment requires a modern browser with javascript enabled.


| Interface | Description |
|---|---|
| AIAfraidOfWater |
Created by Shynixn 2018.
|
| AIAmbientSound |
Created by Shynixn 2018.
|
| AIBase |
Created by Shynixn 2018.
|
| AICarry |
Created by Shynixn 2018.
|
| AIFeeding |
Created by Shynixn 2018.
|
| AIFleeInCombat |
Created by Shynixn 2018.
|
| AIFloatInWater |
Created by Shynixn 2018.
|
| AIFlyRiding |
Created by Shynixn 2018.
|
| AIFlying |
Created by Shynixn 2018.
|
| AIFollowBack |
Created by Shynixn 2018.
|
| AIFollowOwner |
Created by Shynixn 2018.
|
| AIGroundRiding |
Created by Shynixn 2018.
|
| AIHealth |
Created by Shynixn 2018.
|
| AIHopping |
Created by Shynixn 2018.
|
| AIMovement |
Created by Shynixn 2018.
|
| AIWalking |
Created by Shynixn 2018.
|
| AIWearing |
Created by Shynixn 2018.
|
| ChatMessage |
Created by Shynixn 2018.
|
| ChatMessageComponent |
Created by Shynixn 2018.
|
| GuiIcon |
Created by Shynixn 2018.
|
| GuiItem |
Created by Shynixn 2018.
|
| GuiPlayerCache |
Created by Shynixn 2018.
|
| Particle |
Created by Shynixn 2018.
|
| PetBlocksPostSave |
Created by Shynixn 2019.
|
| PetBlocksPreSave |
Created by Shynixn 2019.
|
| PetMeta |
Created by Shynixn 2018.
|
| PetPostSpawn |
Created by Shynixn 2019.
|
| PetPreSpawn |
Created by Shynixn 2019.
|
| PlayerMeta |
Created by Shynixn 2018.
|
| Position |
Created by Shynixn 2018.
|
| PropertyTrackable |
Created by Shynixn 2019.
|
| ScriptResult |
Created by Shynixn 2018.
|
| Skin |
Created by Shynixn 2018.
|
| Sound |
Created by Shynixn 2018.
|


Navbar with offcanvas examples
This example shows how responsive offcanvas menus work within the navbar. For positioning of navbars, checkout the top and fixed top examples.
From the top down, you'll see a dark navbar, light navbar and a responsive navbar—each with offcanvases built in. Resize your browser window to the large breakpoint to see the toggle for the offcanvas.


Class DisulphideBridgeCriteria
- java.lang.Object
-
- io.github.WeronikaJargielo.protein_interaction_finder.DisulphideBridgeCriteria
-
public class DisulphideBridgeCriteria extends java.lang.Object
Class representing criteria for identifying disulphide bridges. See here.
-
-
Constructor Summary
Constructors Constructor Description DisulphideBridgeCriteria()
Instantiates new disulphide bridges criteria using default boundary values.DisulphideBridgeCriteria(double minDistanceBtwSulphurs, double maxDistanceBtwSulphurs, double minAbsDihAngleSS, double maxAbsDihAngleSS, double lowerRangeMinAbsDihAngle1, double lowerRangeMaxAbsDihAngle1, double upperRangeMinAbsDihAngle1, double upperRangeMaxAbsDihAngle1, double lowerRangeMinAbsDihAngle2, double lowerRangeMaxAbsDihAngle2, double upperRangeMinAbsDihAngle2, double upperRangeMaxAbsDihAngle2)
Instantiates new disulphide bridges criteria using custom boundary values.
-
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description boolean
equals(java.lang.Object o)
double
getDistanceBtwCAs()
Returns maximum distance between CA atoms of participating cysteines.double
getDistanceBtwCBs()
Returns maximum distance between CB atoms of participating cysteines.double
getLowerRangeMaxAbsDihAngle1()
Returns maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in first range.double
getLowerRangeMaxAbsDihAngle2()
Returns maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in first range.double
getLowerRangeMinAbsDihAngle1()
Returns minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in first range.double
getLowerRangeMinAbsDihAngle2()
Returns minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in first range.double
getMaxAbsDihAngleSS()
Returns maximum dihedral angle between planes formed by CB1, S1, S2 and S1, S2, CB2 atoms (1 - first cysteine, 2 - second cysteine).double
getMaxDistanceBtwSulphurs()
Returns maximum distance between sulphur atoms of participating cysteines.double
getMinAbsDihAngleSS()
Returns minimum dihedral angle between planes formed by CB1, S1, S2 and S1, S2, CB2 atoms (1 - first cysteine, 2 - second cysteine).double
getMinDistanceBtwSulphurs()
Returns minimum distance between sulphur atoms of participating cysteines.double
getUpperRangeMaxAbsDihAngle1()
Returns maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in second range.double
getUpperRangeMaxAbsDihAngle2()
Returns maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in second range.double
getUpperRangeMinAbsDihAngle1()
Returns minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in second range.double
getUpperRangeMinAbsDihAngle2()
Returns minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in second range.int
hashCode()
java.lang.String
toString()
-
-
-
Constructor Detail
-
DisulphideBridgeCriteria
public DisulphideBridgeCriteria()
Instantiates new disulphide bridges criteria using default boundary values. See here.
-
DisulphideBridgeCriteria
public DisulphideBridgeCriteria(double minDistanceBtwSulphurs, double maxDistanceBtwSulphurs, double minAbsDihAngleSS, double maxAbsDihAngleSS, double lowerRangeMinAbsDihAngle1, double lowerRangeMaxAbsDihAngle1, double upperRangeMinAbsDihAngle1, double upperRangeMaxAbsDihAngle1, double lowerRangeMinAbsDihAngle2, double lowerRangeMaxAbsDihAngle2, double upperRangeMinAbsDihAngle2, double upperRangeMaxAbsDihAngle2)
Instantiates new disulphide bridges criteria using custom boundary values. See here.- Parameters:
minDistanceBtwSulphurs
- Minimum distance between sulphur atoms of participating cysteines.maxDistanceBtwSulphurs
- Maximum distance between sulphur atoms of participating cysteines.minAbsDihAngleSS
- Minimum dihedral angle between planes formed by CB1, S1, S2 and S1, S2, CB2 atoms (1 - first cysteine, 2 - second cysteine).maxAbsDihAngleSS
- Maximum dihedral angle between planes formed by CB1, S1, S2 and S1, S2, CB2 atoms (1 - first cysteine, 2 - second cysteine).lowerRangeMinAbsDihAngle1
- Minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in first range.lowerRangeMaxAbsDihAngle1
- Maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in first range.upperRangeMinAbsDihAngle1
- Minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in second range.upperRangeMaxAbsDihAngle1
- Maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in second range.lowerRangeMinAbsDihAngle2
- Minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in first range.lowerRangeMaxAbsDihAngle2
- Maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in first range.upperRangeMinAbsDihAngle2
- Minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in second range.upperRangeMaxAbsDihAngle2
- Maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in second range.
-
-
Method Detail
-
getDistanceBtwCAs
public double getDistanceBtwCAs()
Returns maximum distance between CA atoms of participating cysteines.- Returns:
- Maximum distance between CA atoms of participating cysteines.
-
getDistanceBtwCBs
public double getDistanceBtwCBs()
Returns maximum distance between CB atoms of participating cysteines.- Returns:
- Maximum distance between CB atoms of participating cysteines.
-
getMinDistanceBtwSulphurs
public double getMinDistanceBtwSulphurs()
Returns minimum distance between sulphur atoms of participating cysteines.- Returns:
- Minimum distance between sulphur atoms of participating cysteines.
-
getMaxDistanceBtwSulphurs
public double getMaxDistanceBtwSulphurs()
Returns maximum distance between sulphur atoms of participating cysteines.- Returns:
- Maximum distance between sulphur atoms of participating cysteines.
-
getMinAbsDihAngleSS
public double getMinAbsDihAngleSS()
Returns minimum dihedral angle between planes formed by CB1, S1, S2 and S1, S2, CB2 atoms (1 - first cysteine, 2 - second cysteine).- Returns:
- Minimum dihedral angle between planes formed by CB1, S1, S2 and S1, S2, CB2 atoms (1 - first cysteine, 2 - second cysteine).
-
getMaxAbsDihAngleSS
public double getMaxAbsDihAngleSS()
Returns maximum dihedral angle between planes formed by CB1, S1, S2 and S1, S2, CB2 atoms (1 - first cysteine, 2 - second cysteine).- Returns:
- Maximum dihedral angle between planes formed by CB1, S1, S2 and S1, S2, CB2 atoms (1 - first cysteine, 2 - second cysteine).
-
getLowerRangeMinAbsDihAngle1
public double getLowerRangeMinAbsDihAngle1()
Returns minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in first range.- Returns:
- Minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in first range.
-
getLowerRangeMaxAbsDihAngle1
public double getLowerRangeMaxAbsDihAngle1()
Returns maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in first range.- Returns:
- Maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in first range.
-
getUpperRangeMinAbsDihAngle1
public double getUpperRangeMinAbsDihAngle1()
Returns minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in second range.- Returns:
- Minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in second range.
-
getUpperRangeMaxAbsDihAngle1
public double getUpperRangeMaxAbsDihAngle1()
Returns maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in second range.- Returns:
- Maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of first cysteine in second range.
-
getLowerRangeMinAbsDihAngle2
public double getLowerRangeMinAbsDihAngle2()
Returns minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in first range.- Returns:
- Minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in first range.
-
getLowerRangeMaxAbsDihAngle2
public double getLowerRangeMaxAbsDihAngle2()
Returns maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in first range.- Returns:
- Maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in first range.
-
getUpperRangeMinAbsDihAngle2
public double getUpperRangeMinAbsDihAngle2()
Returns minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in second range.- Returns:
- Minimum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in second range.
-
getUpperRangeMaxAbsDihAngle2
public double getUpperRangeMaxAbsDihAngle2()
Returns maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in second range.- Returns:
- Maximum dihedral angle between planes formed by N, CA, CB and CA, CB, S atoms of second cysteine in second range.
-
equals
public boolean equals(java.lang.Object o)
- Overrides:
equals
in classjava.lang.Object
-
hashCode
public int hashCode()
- Overrides:
hashCode
in classjava.lang.Object
-
toString
public java.lang.String toString()
- Overrides:
toString
in classjava.lang.Object
-
-


Chemutai and Lydia Wafula out to defend MTN Marathon titles
by James BakamaOrganisers said that Ugandan Policeman Chemutai and Kenya Prisons’ Wafula have confirmed participation in Sunday’s race.
Ugandans take part in the MTN Marathon in Kampala. File Photo
Sunday
42km: Start time 6.45 am
Upper Kololo Terrace
21km: Start time 7.10 am
10km: Start time 7.20 am
5km: Start time 7.15 am
Defending champions Joshua Chemutai and Lydia Wafula are back to defend their MTN Kampala Marathon titles.
Organisers said that Ugandan Policeman Chemutai and Kenya Prisons’ Wafula have confirmed participation in Sunday’s race.
The race will also feature seasoned Ethiopians Tedla Kidist and Bira Guta together with Eritreans Hibret Yohannes and Petro Shaku.
The marathon will be flagged off at 6.45 am while the 21km, 10km, and 5km events will start at 7.10 am, 7.20 am and 7.15 am respectively.
While the 5, 21 and 42km races will be flagged off at Upper Kololo Terrace, the 10km event that attracts the biggest entry will start at Kololo airstrip.
The 16th edition of the marathon will have the 42 and 21km races avoiding the congested Wandegeya, northern bypass and Entebbe Road areas.
One of the route designers Paul Okello said that most of the running will be done in the areas of Bugoloobi, Nakasero, Namuwongo, Kololo and Jinja Road.
These areas will feature one loop for the 21km event and double that for the marathon.
The 10km route has been maintained with participants running on Elgon Terrace, Upper Kololo Terrace, Lugogo Bypass, Kira Road, Yusuf Lule, Lower Kololo Terrace and back to the airstrip.
The 5km has participants on Mabua Road, John Babiiha Avenue, Acacia Mall, Prince Charles Drive, Ekoko Avenue, Upper Kololo Terrace and back to the airstrip.