---
layout: null
section-type: about
title: About
---
## About
I am Jay, as in Jayant.
My last name is pronounced **Per** - **Choo** - **Ray**
My previous work has been eclectic- From writing a Twitter account manager, to a web app for musicians to create and share music à la Google Drive, to writing a Tableau Web Connector for the Arlington cemetery.
Currently, I work as a Senior Analyst, Business Intelligence and Analytics for Target, where I help the merchandizing team with assortment decisions.
In my previous role I used to develop data visualizations for ACT. During my time there, I worked on applying Machine Learning techniques to problems in the education domain.
I can write Python, JavaScript, R, Ruby and Java, in decreasing order of confidence.
Outside work, I helped incubate GDG Indore, tried to maintain a personal blog thrice with varying degrees of success, and featured on national television.
I have also done some small consulting gigs for companies in the Iowa City area.
The proudest moment of my professional life was discovering a bug in a three year old Tableau API.
If you are a recruiter, please head to the FAQ section.


Chapters 27-28 / 37
Chapter 27 ran through an example of creating an iOS app. Chapter 28 ran through an example of creating a Mac App. I could follow the directions but do I really know what I typed?
Chapters 27-28 / 37
Chapter 27 ran through an example of creating an iOS app. Chapter 28 ran through an example of creating a Mac App. I could follow the directions but do I really know what I typed?
Chapters 18-26 /37
I feel like a sieve. Going through these chapters have been a slog and I feel like I’ve forgotten most of what I’ve read already. Ironically, the hardest chapter to wrap my head around was called, “Preventing Memory Leaks.”
There was a good chapter called “Writing Files with NSString and NSData.” This is probably because the benefit of the tool is more obvious.
In the end, like any spoken language, it’s easier to understand when someone else is using it than trying to compose your own use of the language. It’s all part of overcoming the learning curve through practice.
Aaron Hilligass was on the Generation Podcast #027. If you remember, the book I’m currently going through is Objective-C Programming: The Big Nerd Ranch Guide, written by Aaron.
I could sympathize with Gabe (a.k.a. MacDrifter) when he said he had the books for about a year and haven’t made it through them yet. It’s takes time and momentum to get through a programming book. I think that scripting languages have an advantage in this case because you can start doing useful things quickly. With a compiled language, there is a lot of knowledge infrastructure to build before you can start writing something useful.
One useful comment that Aaron made in the interview was how he thought the book(s) should be approached. He said that learning to program should be done in front of a computer. I’ve been reading the book first, sometimes even a few chapters, before sitting in front of the computer. This is mostly because it’s convenient for me to carry the book around and read a few minutes here and there. Having the computer adds a minimum time for each session. I’ll definitely admit, reading separately feels less effective.
Chapters 12-17 / 37
These 5 chapters jumped from C into Objective-C. They covered objects, messages (which is a term I wasn’t familiar with), NSString and NSArrays, and documentation.
I’m curious to know what NS means. It’s probably something obvious but I haven’t figured it out yet. It has been interesting getting used to the syntax, but it has been easier than trying to understand how to use pointers, so I think that’s a plus. There are conventions in the writing that are very different than what I’m used to in scripting languages like Perl, Python, and Ruby. For example, it seems like there should be a way to simplify: NSDate *myDate = [[NSDate alloc] init]
You can use a class method like: NSDate *myDate = [NSDate date]
but again, it seems like that could be simplified. There are probably good reasons for why it’s done, I just don’t know what they are yet.
The one thing that continues to impress me is how fast someone can type using the tab completion. Quite impressive.
Chapters 10-11 / 37
Chapter 10 described structs. It kind of looks like a class in other languages but may not be one. Can’t wait to find out more.
Chapter 11 talks about heaps. I can see how memory allocation and use can be important. I’m not quite sure of the difference between –> and dot notation in getting values of data in a struct. Again, I can’t wait for this to be explained further in the book.
Chapter 11 is also the last chapter for the C background before Objective-C starts.
Chapters 6-9 / 37
Chapter 6 is about numbers and different types that represent numbers.
Chapter 7 is about loops. After ruby and pythons, for loops in C bring me back to loops in Perl. It always. Seems weird to use semi-colons to separate the initiation ; check; iteration. I’m so used to having the semi-colon represent the end of the statement. Nonetheless, it’s just a matter of getting used to it.
Chapters 8 and 9 are about pointers, addresses, and passing-by-reference. I remember learning about them 20 years ago when I tried C before. I get the idea and realize its more efficient than othet data structures but I don’t get why they are necessary. I’m hoping this is one where using it more will make me appreciate it better. Still, my understanding of them are on shaky ground.
Chapter 5 / 37
Chapter 5 was about functions. As I was typing, I noticed some things that made me a happy camper. After using Emacs for decades, some of he basic Emacs navigation works as well as ctrl-k/ctrl-y.
The second thing I noticed was auto completion. It was easy to tab to autofill a long function name. It was really nice that tab jumped to the variables and the end of the line for the trailing semi-colon.
Other observations: at least the author uses camelCase for function and variable names. This may be Objective-C convention.
Also, having the ability to add breakpoints is really nice. Will this replace adding print statements to debug? I hope so.
Chapter 2/37 It’s 8 pages. How long can 8 pages take?
It started with an update of XCode…which failed to install. This was followed by clearing diskspace (I was down to 3 GB on my old SSD). Luckily, it was straight forward and did fix the problem. These things happen.
It took a few minutes to figure out the differences in the interface compared to the book. Nothing big but it’s quite impressive how much can change in 2 years.
The actual program took 2 minutes to type and run. All good. Full speed ahead!
Chapters 3 & 4 / 37
Chapter 3 was nice and short, introducing variables. Mostly, it’s getting the syntax since variables are like variables from other languages.
Chapter 4 introduced if/else statements. There were some syntax elements to remember. For example, the if clause is like:
if (condition1) { Do this; } else if (condition2) { Do this instead; } else { Ok, do this; }
I never remember how else if is used switching between different shells and scripting languages.
Also, it seems like c uses || and && but not ‘or’ or ‘and’. I’m hoping Xcode with catch those since those mistakes will happen often.
I like that c had ternary operators.
int value = conditional ? value_true : value_false
Also, there wasn’t a programming assignment in chapter 4 which made it easy to read away from the computer.
Call it having lots of interests, call it attention deficit… actually, you should call it attention deficit. I’m going to deviate into Objective-C for a bit. I have Aaron Hillegass’ Objective-C Programming book. It’s 265 pages and 37 chapters. If I can do 5 chapters a week, it should be doable in 2 months. We’ll see how it goes, and if successful, how much I really know when I’m done.
Let’s do this thing!
P.S. Luckily, the first chapter is called “You and this book” and is only two pages, because I’m already sleepy.


In this lab we will get back to age-structured populations: specifically, we will play with matrix projection models! Rememeber that while matrix population models may look complicated, they are just a fancy, age/stage structured version of basic exponential growth!
We all remember the finite-population-growth equation:
\(N_{t+1}=\lambda \cdot N_t \qquad \text{(Eq. 1)}\),
where \(N\) is abundance (as always), \(t\) is time, often in years but could be any time units, and \(\lambda\) is the multipicative growth rate over the time period \(t \rightarrow t+1\)
The matrix population growth equation looks pretty much the same!
\(\mathbf{N}_{t+1} = \mathbf{A} \cdot \mathbf{N}_{t} \qquad \text{(Eq. 2)}\),
where \(\mathbf{N}\) is a vector of abundances (abundance for all stages), and \(\mathbf{A}\) is the transition matrix, which we have seen before.
We can be more explicit about this if we re-write the above equation this way:
\(\begin{bmatrix}N_1\\ N_2\\N_3 \end{bmatrix}_{t+1}=\begin{bmatrix}0 & F_2 & F_3\\ P_{1 \rightarrow 2} & P_{2 \rightarrow 2} & 0\\ 0 & P_{2 \rightarrow 3} & P_{3 \rightarrow 3}\end{bmatrix} \cdot \begin{bmatrix}N_1\\ N_2\\N_3 \end{bmatrix}_{t} \qquad \text{(Eq. 3)}\)
Where \(P_{1 \rightarrow 2}\) is the probability of advancing from stage 1 to 2, and \(F_2\) is the fecundity of stage 2.
NOTE: fecundity is NOT the same thing as birth rate, \(b\). What’s the difference?
Birth rate, \(b_t\), is the per-capita rate of offspring production for stage \(t\)
Fecundity, \(F_t\), is the _per-capita rate by which an individual of stage \(t\) contributes new offspring to the population at time \(t+1\). Sounds pretty similar, right? What’s the difference??
Fecundity also takes into account the survival rate from \(t\) to \(t+1\)!! For an adult of stage \(t\) to contribute to the next generation, it must both survive and reproduce!.
\(F_t = P_{1 \rightarrow 2} \cdot b_{t+1} \qquad \text{(Eq. 4)}\)
There is a lot we can do with matrix population models. The most obvious one is projection:
We have already seen the projection equation (Eq. 2, above). Here is how we can implement this in R:
Year1 <- projection_matrix %*% Abundance_year0 # matrix multiplication!
Let’s try it:
First, build a projection matrix:
projection_matrix <- matrix(
c(
0, 1.2, 3.1,
0.4, 0, 0,
0, 0.75, 0
)
,nrow=3,ncol=3,byrow=T
)
projection_matrix
## [,1] [,2] [,3]
## [1,] 0.0 1.20 3.1
## [2,] 0.4 0.00 0.0
## [3,] 0.0 0.75 0.0
Next, let’s build an initial abundance vector:
Abundance_year0 <- c(1000,0,0)
Abundance_year0
## [1] 1000 0 0
Now we can run the code for real!
Year1 <- projection_matrix %*% Abundance_year0 # matrix multiplication!
Year1
## [,1]
## [1,] 0
## [2,] 400
## [3,] 0
Now we have 300 individuals in stage 2!
Let’s project one more year:
Year2 <- projection_matrix %*% Year1 # matrix multiplication!
Year2
## [,1]
## [1,] 480
## [2,] 0
## [3,] 300
Finally, here is some code to project many years into the future! You may want to re-use some of this code for the exercises below.
nYears <- 20 # set the number of years to project
TMat <- projection_matrix # define the projection matrix
InitAbund <- Abundance_year0 # define the initial abundance
## NOTE: the code below can be re-used without modification:
allYears <- matrix(0,nrow=nrow(TMat),ncol=nYears+1) # build a storage array for all abundances!
allYears[,1] <- InitAbund # set the year 0 abundance
for(t in 2:(nYears+1)){ # loop through all years
allYears[,t] <- TMat %*% allYears[,t-1]
}
plot(1,1,pch="",ylim=c(0,max(allYears)),xlim=c(0,nYears+1),xlab="Years",ylab="Abundance",xaxt="n") # set up blank plot
cols <- rainbow(3) # set up colors to use
for(s in 1:3){
points(allYears[s,],col=cols[s],type="l",lwd=2) # plot out each life stage abundance, one at a time
}
axis(1,at=seq(1,nYears+1),labels = seq(0,nYears)) # label the axis
legend("topleft",col=cols,lwd=rep(2,3),legend=paste("Stage ",seq(1:nrow(TMat)))) # put a legend on the plot
Clearly this is a growing population. But let’s see exactly what \(\lambda\) is!
library(popbio)
## Warning: package 'popbio' was built under R version 3.3.2
lambda(projection_matrix)
## [1] 1.138728
Pretty easy right?
NOTE: we are using a “package” in R to make these analyses super easy! So if you don’t already have the “popbio” package, go to the “Packages” tab in R studio (should be at the top of the lower right panel), click on “Install”, and then type “popbio” in the “Packages” field in the pop-up window, then click on the “Install” button.
Or just use the following code:
install.packages("popbio")
Clearly the population doesn’t reach a stable age distribution until a few years into our simulation. What exactly is the stable age distribution here? We can do this in R:
stable.stage(projection_matrix)
## [1] 0.6318614 0.2219535 0.1461852
And that is really all we need to know to get started with matrix-based population models!
In this exercise, you will have a chance to play around with a very simple matrix population model. But first, you need to translate a life table into a transition matrix!
Here is a life table you may remember.
## Age S_x b_x l_x
## 1 0 350 0.0 1.000000000
## 2 1 50 5.2 0.142857143
## 3 2 25 5.5 0.071428571
## 4 3 10 4.7 0.028571429
## 5 4 2 3.3 0.005714286
## 6 5 0 0.0 0.000000000
1a. Translate the above life table into a five-age-class transition matrix. In your written lab report, provide the transition matrix and describe the formulae used to compute the following two elements: (1) row 1 column 4 and (2) row 4 column 3. This is a bit harder than it sounds!
Keep the following points in mind:
For individuals of “Age class 1” to contribute new offpring (individuals of age-class 1) to the population in the next time step (\(F_1\)), they have to survive their first year of life (\(P_{1 \rightarrow 2}\)) AND produce offspring when they are exactly 1 year of age (which they do at the rate of \(b\) at age 1).
No individual ever stays in the same age-class two time steps in a row- they either transition to the next age-class or they die.
1b. Use R to compute the finite rate of growth for the population (\(\lambda\)). Is this a growing or declining population? Show your R code!
1c. Use R to compute the stable-age distribution for the population (S.A.D.). Show your R code! Now imagine you have a total population size of 671. Assuming this population is at S.A.D., how many individuals are in each age-class?
1d. Use R to project this population for 30 years, starting with the S.A.D. population you computed in part 1c. Show your R code. What is the total abundance after 30 years? Re-do the calculation using Eq. 1 and the “Lambda” value you computed in 1b. Do you get the same answer?  Why is the final abundance estimate different from your previous calculations?
Return to the InsightMaker model you created in Lab 3 (exercise 3 – that is, the original model, without the carrying capacity component you implemented in Exercise 4 of Lab 3). Your model should look something like this:
Make sure the parameters are at the original values specified in Exercise 3 of Lab 3 (before altering mortality rates as part of lab 3 question 3e.)
2a. Translate this InsightMaker model into a projection matrix. This is not quite as straightforward as it might sound. Pay close attention to the difference between survival (transition to the next stage class) and mortality. In your write-up please provide your transition matrix.
2b. Starting with 75 individuals, all in Age class 1, project the population 20 years into the future, using both InsightMaker and R. You don’t need to show your R code or the InsightMaker model this time- just provide graphical evidence (that is, provide two plots- one showing the results of the R simulation and the other showing the results of the InsightMaker simulation). These plots should look essentially the same!
2c. Now let’s go the other way around. Build an InsightMaker model that represents the same population as the stage matrix below. Share your InsightMaker model with your instructors and provide the URL in your write-up.
2d. Use this stage matrix to project the population 20 years into the future, starting with 100 individuals at S.A.D. No need to show your R code- simply provide a plot of projected abundance of each stage over the 20 year simulation. Do the same in InsightMaker (project the population 20 years into the future), and make sure the population dynamics look the same in R and InsightMaker. Provide the InsightMaker plot to show that the two models are identical.
In this class we have stressed the importance of density dependence in determining and regulating the dynamics of wild populations. Were any of the population models in this lab density-dependent? NO! Let’s build a density-dependent vital rate into our model. BUT instead of doing what we have done before (birth and death rates are density-dependent), let’s build a model where growth (transition from one stage to the next) is density dependent but stage-specific survival does not change! Here is the scenario:
The stage matrix in this exercise is representative of a population at very low abundance (near 0). If abundance increases above the carrying capacity of 100 individuals, no individuals can transition from stage 2 to stage 3 (grow to full maturity)- however, overall survival rates and stage-specific fecundity rates remain unchanged.
2e. Provide the URL for your new, density-dependent InsightMaker model. Describe briefly what components and equations you added to the model to implement density-dependent growth from stage 2 to stage 3. Run the model for 20 years and provide a plot of abundance over time. Is this population regulated? Explain your reasoning.
stmat <- read.csv("stage_matrix1.csv")
stmat <- as.matrix(stmat[,-1])
rownames(stmat) <- colnames(stmat)
stmat
## Stage1 Stage2 Stage3
## Stage1 0.02 0.30 0.85
## Stage2 0.45 0.20 0.00
## Stage3 0.00 0.65 0.70
This should be quick and relatively painless! As a test of your understanding, try to implement the following passage as a matrix projection model:
We assumed that the Red-tailed hawk life history could be described in terms of three major life stages: hatchling, juvenile, and adult (generally the third year of life and beyond). Adults are the primary reproductive stage, and produce an average of 3 new hatchlings each year. Juveniles tend to produce only 1 new hatchling per year on average. We assumed that adults experienced an average of 18% mortality each year. Juvenile mortality was set at 30% per year. Approximately 5% of juveniles fail to transition to adults, remaining in the juvenile phase. Finally, hatchlings had a 20% chance of surviving and transitioning to become juveniles. We initialized the population with 1000 hatchlings, 150 juveniles, and 5 adults.
3a. Provide your transition matrix in your write-up.
3b. Is this population at S.A.D. at time 0? If not, provide an example of an initial population structure that IS at S.A.D.
3c. What is the finite growth rate, Lambda, for this population (at S.A.D.)?
Please bundle all your responses into a single Word document and submit using WebCampus!
URLs for your InsightMaker models should be pasted in your lab submission (MS Word document). See details below…
Due Mar. 3 at 11 am.


Create account
or
Sign up with Google
{{ error.message }}
An email has been sent to your inbox. Click on the link to verify your account.
Log in


Beware Underlanders, time hangs by a thread, the hunters are hunted, white water runs red The gnawers will strike to extinguish the rest, the hope of the hopeless resides in a quest An Overland warrior, a son of the Sun, he may bring us back light, he may bring us back none, but gather your neighbors and follow his call, or the rats will most surely devour us all Two over, two under, of royal descent, two flyers, two crawlers, two spinners assent One gnawer beside, and one lost up ahead, and eight will be left when we count up the dead The last one to die must decide where he stands, the fate of the eight is contained in his hands, so bid him take care, bid him look where he leaps so that life may be death, and death life again reaps
If under fell, if over leaped, if life was death, and death life reaped, something rises from the gloom to make the Underland a tomb Hear it scratching down below, Rat of long forgotten snow Evil cloaked in coat of white, will the warrior drain your light? What could make the warrior weak? What do burning gnawers seek? Just a barely speaking pup, who holds the land of under up Die the baby, die his heart, die his most essential part, die the peace that rules the hour, gnawers have their key to power
Warmblood now a bloodbourne death, will rob your body of it's breath, will mark your skin and seal your fate, the Underland becomes a plate Turn and turn and turn again, you see the what but not the when, remedy and wrong entwine, and so they form a single vine Bring the warrior from above, if yet his heart is swayed by love, bring the princess or despair, no crawlers care without her there Turn and turn and turn again, you see the what but not the when, remedy and wrong entwine, and so they form a single vine Those whose blood runs red and hot, must join to seek the healing spot, in the cradle, find the cure, for that which makes the blood impure Turn and turn and turn again, you see the what but not the when, remedy and wrong entwine, and so they form a single vine Gnawer, human, set aside, the hatreds that reside inside, for if the flames of war are fanned, all warmbloods lose the Underland Turn and turn and turn again, you see the what but not the when, remedy and wrong entwine, and so they form a single vine


Sample page
Sample text by.Blind Text Generator
One morning...
One morning, when Gregor Samsa woke from troubled dreams, he found himself transformed in his bed into a horrible vermin. He lay on his armour-like back, and if he lifted his head a little he could see his brown belly, slightly domed and divided by arches into stiff sections. The bedding was hardly able to cover it and seemed ready to slide off any moment. His many legs, pitifully thin compared with the size of the rest of him, waved about helplessly as he looked.
"What's happened to me? "
"What's happened to me? " he thought. It wasn't a dream. His room, a proper human room although a little too small, lay peacefully between its four familiar walls. A collection of textile samples lay spread out on the table - Samsa was a travelling salesman - and above it there hung a picture that he had recently cut out of an illustrated magazine and housed in a nice, gilded frame.
It showed a lady fitted out...
It showed a lady fitted out with a fur hat and fur boa who sat upright, raising a heavy fur muff that covered the whole of her lower arm towards the viewer. Gregor then turned to look out the window at the dull weather. Drops of rain could be heard hitting the pane, which made him feel quite sad. "How about if I sleep a little bit longer and forget all this nonsense", he thought, but that was something he was unable to do because he was used to sleeping on his right, and in his present state couldn't get into that position.
However hard he threw himself onto his right
However hard he threw himself onto his right, he always rolled back to where he was.  "Oh, God", he thought, "what a strenuous career it is that I've chosen! Travelling day in and day out.
Doing business like this...
Doing business like this takes much more effort than doing your own business at home, and on top of that there's the curse of travelling, worries about making train connections, bad and irregular food, contact with different people all the time so that you can never get to know anyone or become friendly with them. It can all go to Hell! " He felt a slight itch up on his belly; pushed himself slowly up on his back towards the headboard so that he could lift his head better; found where the itch was, and saw that it was covered with lots of little white spots which he didn't know what to make of; and when he tried to feel the place with one of his legs he drew it quickly back because as soon as he touched it he was overcome by a cold shudder. He slid back into his former position.  You've got


Preparation time
less than 30 mins
Cooking time
over 2 hours
Serves
Serves 4-6
Preheat the oven to 220C/400F/Gas 7.
For the oxtail, season the pieces of oxtail with salt and freshly ground black pepper and lightly dust them with a little flour.
Place the oxtail into a roasting tin and roast in the oven for 30 minutes, turning the oxtail pieces after 15 minutes to make sure they are nicely coloured on both sides.
Meanwhile melt the butter in a pan over a low heat and gently cook the onion, garlic and thyme for 3-4 minutes until soft, stirring occasionally.
Add the flour and the tomato purée and stir well.
Gradually pour in the red wine and stock, stirring well between additions to avoid lumps forming, then bring the mixture to the boil.
Add the pieces of roasted oxtail to the pan, then cover and simmer gently over a low heat for about two hours. Check the pieces of oxtail - the meat should be tender and easily removed from the bone. If not, replace the lid and cook for another 15 minutes and test again.
Drain the oxtail into a colander over a bowl to reserve the sauce.
When the oxtail is cool enough to handle, remove the pieces of meat from the bone and place into a clean saucepan and cover with the reserved sauce. Bring to the boil, then reduce the heat and simmer until the sauce has reduced enough to just coat the meat.
Meanwhile, for the dressing, whisk all of the dressing ingredients together in a clean bowl and season, to taste, with salt and freshly ground black pepper.
For the salad, place the pea shoots, salad and herb leaves, peas and broad beans into a bowl and cover with most of the dressing. Mix well to coat and arrange a little salad in the centre of each serving plate.
To serve, spoon a little of the warm oxtail meat around the salad with a small amount of sauce just coating the meat, then spoon a little of the remaining dressing over the oxtail.


@composi/core
CDN
Run in Browser without Build
It is possible to run @composi/core directly in the browser without a build step. This is a great way to quickly prototype an idea, or try out @composi/core with something you already have build. The advantage of the build step is it allows you to use JSX to define the markup for your components. Without a build step you have two choices: use the h
function to define markup, or use the htm
module to define markup. htm
is a tiny module that allows you to use a JSX-like syntax in the browser by means of a tagged template. This is not the same as using ordinary template literals, as the result gets converted into virtual nodes that @composi/core can render to the DOM.
This technique takes advantage of the fact that modern browsers can import ES6 modules directly. You do need to let the browser know that the code you are importing is an ES6 module. You do this on the script tag by providing the attribute type='module'
.
Setup for in Browser Use
To use @composi/core in the browser, create a folder and name it whatever you want. In it create an index.html file, and a JavaScript file. In this case we're going to name it app.js
. You can also create a CSS file if you want. This means our project structure should look like this:
MyProject-|
|-app.js
|-index.html
|-style.css
In app.js
we are going to import three files: @composi/core, @composi/merge-objects, and htm. Notice how each import ends with ?module
. This is to let the browser know that these are ES6 modules:
import { h, render, run, union } from 'https://unpkg.com/@composi/core@2.6.1/dist/composi-core.mjs?module'
import { clone } from 'https://unpkg.com/@composi/merge-objects@1.1.0/src/index.js?module'
import { htm } from 'https://unpkg.com/htm.mjs?module'
// Pass the @composi/core h function to htm,
// and capture the result in variable 'html'.
// We'll use this to define markup.
const html = htm.bind(h)
Next create basic html to import this code:
<!DOCTYPE html>

<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
<link rel="stylesheet" href="/styles.css">

Notice that the script tag has the type module
. This is very important so that the browser knows it is important and ES6 module. For the CSS you can provide whatever you need to. We used absoltute paths here because this will need to be run with a server.
CSS
For this example, we're going to use the following CSS:
:root {
--masthead-background-color:#f10;
--masthead__header-color:#fff
}
html, body {
margin: 0;
padding: 0;
height: 100%;
}
header {
background-color:var(--masthead-background-color);
padding:20px;
}
header h1 {
color:var(--masthead__header-color);
margin:0;font-size:2rem;
}
section {
padding: 2rem;
}
.container {
width: 350px;
}
p {
display: flex;
justify-content: space-between;
}
input {
flex: 1;
margin-right: 10px;
}
.list {
list-style: none;
border: solid 1px #ccc;
margin: 0;
padding: 0;
}
.list li {
padding: 5px 10px;
border-bottom: solid 1px #ccc;
display: flex;
flex-direction: row;
}
.list li:last-of-type {
border: none;
}
.list li > span {
flex: 1;
}
.delete-item {
border: solid 1px red;
background-color: white;
color: red;
transition: all .25s ease-out;
cursor: pointer;
}
.delete-item:hover {
color: white;
background-color: red;
}
.add-item {
border: solid 1px green;
background-color: green;
color: white;
transition: all .25s ease-out;
cursor: pointer;
}
.add-item:hover {
color: green;
background-color: white;
}
App.js
And now, for the app.js
file we're going to use the following:
import { h, render, run, union } from 'https://unpkg.com/@composi/core@2.6.1/dist/composi-core.mjs?module'
import { clone } from 'https://unpkg.com/@composi/merge-objects@1.1.0/src/index.js?module'
import { htm } from 'https://unpkg.com/htm.mjs?module'
// Pass the @composi/core h function to htm,
// and capture the result in variable 'html'.
// We'll use this to define markup.
const html = htm.bind(h)
function Title({greeting}) {
return html`

Hello, ${greeting}!

`
}
render(html`<${Title} greeting='Everyone'/>`, 'header')
const ref = {
target: undefined
}
const Msg = union(['AddItem', 'DeleteItem'])
function List({state, send}) {
function setTarget(input) {
ref.target = input
}
let inputValue
function getInputValue(value) {
inputValue = value
}
return html`

<input autofocus onmount=${input => setTarget(input)} value=${state.resetInput} type='text' onchange=${e => getInputValue(e.target.value)}>
<button onclick=${() => send(Msg.AddItem(inputValue))} class='add-item'>Add</button>

${
state.fruits.map(fruit => html`

${fruit.value}
<button class='delete-item' onclick=${() => send(Msg.DeleteItem(fruit.key))}>X</button>

`)
}

`
}
const state = {
newKey: 104,
resetInput: '',
fruits: [
{
key: 101,
value: 'Apples'
},
{
key: 102,
value: 'Oranges'
},
{
key: 103,
value: 'Bananas'
}
]
}
function actions(msg, state) {
const prevState = clone(state)
return Msg.match(msg, {
'AddItem': value => {
if (!value) return [prevState]
const key = prevState.newKey++
prevState.fruits.push({key, value})
ref.target.focus()
return [prevState]
},
'DeleteItem': key => {
const filteredFruits = prevState.fruits.filter(fruit => fruit.key != key)
prevState.fruits = filteredFruits
return [prevState]
}
})
}
const program = {
init() {
return [state]
},
view(state, send) {
render(html`<${List} ...${{state, send}} />`, 'section')
},
update(msg, state) {
return actions(msg, state)
}
}
run(program)
Now all we need to do is run this. To do so we need a server. There are a number of ways to do this. I use http-server
. You can install it from NPM:
npm i -g http-server
Run it in the project folder. When it starts it will indicate the url you can use to load in the browser. Copy and paste into the browser and voilá, you should have a fully operation @composi/core app running in the browser without a build process.
HTM
In the previous example we were using htm
to define our component markup. This is a tiny module that lets you use tagged templates with a syntax similar to JSX. There are differences because it is ultimately a template literal. Here we will go over how to use HTM.
html``
You use html``
to define all your markup.
function Title() {
return html`

Hello, World!

`
}
{} = ${}
Whereas JSX uses curly braces to mark off a variable to block of code, HTM used ${}
. Using the previous example, we'll pass in value for the Hello World. Instead of the normal JSX curly braces, we precede them with the $ sign:
function Title({greeting}) {
return html`

Hello, ${greeting}!

`
}
To do a JavaScript code block inside of the markup, we again use curly braces with a $ sign:
function List({state}) {
return (
html`

${
state.fruits.map(fruit => html`<li key=${fruit.key}>${fruit.value}</li>`)
}

`
)
}
<List/> = <${List}/>
To use a functional component as a tag, you need to enclose the function name inside curly braces with the $ sign:
render(<${List}/>, document.body)
{...{state}} = ...${{state}}
To descructure props in a tag, you start with the spread operator, followed by the values to use in curly braces with the $ sign:
render(<${List} ...${{state, send}}/>, document.body)
Notice the difference between this and JSX:
render(<List {...{state, send}}/>, document.body)
Summary
Using @composi/core along with htm in the browser provides and easy way to test out ideas and do quick prototyping. The small size of both @composi/core and htm make this approach very performant.


Team Manager
Ryan
Manager
Employee ID: 1
Office #: 25
Email:
<EMAIL_ADDRESS>Sam
Engineer
Employee ID: 2
GitHub:
sam2
Email:
<EMAIL_ADDRESS>Kris
Intern
Employee ID: 3
School: Harvard
Email:
<EMAIL_ADDRESS>Louis
Engineer
Employee ID: 4
GitHub:
louis23
Email:
louis@gmail.com


|
Shopify SDK for Unity
|
Helper class for binding a product details UI to the data stored within the Product More...
Public Member Functions | |
| void | FillWithProductWithVariants (Product product, ProductVariant[] variants) |
| Fills all of the UI with information from the models that are passed in More... | |
| void | OnSelectedVariant (ProductVariant variant) |
| void | OnSelectProductImage (Sprite sprite) |
| void | NotifyOnAddToCartClicked () |
| void | SetLoadingOverlayVisible (bool visible) |
Public Attributes | |
| Text | Title |
| Text | Price |
| Text | Description |
| Dropdown | VariantDropdownMenu |
| GameObject | ProductImageViewArea |
| ProductImageHolder | ProductImageHolderTemplate |
| GameObject | ProductImageContainer |
| RemoteImageLoader | ActiveImage |
| Animator | LoadingOverlayAnimator |
| UnityEvent | OnAddToCartClicked = new UnityEvent() |
Properties | |
| ProductVariant | CurrentSelectedVariant [get] |
| The currently selected product variant shown by the UI. More... | |
| Product | Product [get] |
Helper class for binding a product details UI to the data stored within the Product
|
inline |
Fills all of the UI with information from the models that are passed in
| product | The Product to fill the UI from |
| variants | The ProductVariants of that product |
|
get |
The currently selected product variant shown by the UI.


Hi, I am
Maxwell McClure
Beginner web developer
My Portfolio
Projects
Contact
My Portfolio
These are my projects
Tribute Page
Survey Form
Product Landing Page
Technical Documentation Page
Contact me
Linked In
Github


In the classical inheritance paradigm, object instances inherit their properties and functions from a class, which acts as a blueprint for the object. Object instances are typically created using a constructor and the new
keyword.
In the prototypal inheritance paradigm, object instances inherit directly from other objects and are typically created using factory functions or Object.create()
.


AppendedString
$myString
or
initialString
AppendedString
$myString
As you can see, the delimiter is inserted before the appended string, but not if the string it is appended to is empty.
This makes it easy to use within loops.
delimiter - a string to insert between appended elements
See also and .


Document folders help organize various documents of an employee. In each document folder you can designate the type of documents uploaded and associated document fields. A Document type helps capture document information along with the uploaded document such as Passport Number, Expiration Date of a Passport document upload.


Dendrogram Matrix
Dendrogram Matrix for looking at lots of small hierarchies of categories.
Code on GitHub


TunerStudio Help Topics:
Firmware & Tuning Help
Software, firmware & ini roles
Creating a Project
Configuring a GPS
Performance and economy fields
Single Dialog Loading / Saving
Auto Logging
2D Table Help
MS3 / MS3 Pro - SD Card
Download
VE Analyze Live!
- Understanding VE Analyze
- Primary Controls
- Recommended Table
- Heat Maps
- Advanced Settings
- Lambda Delay
- Using VE Analyze Live!
Warmup
Analyze Live!
- Overview
- Primary Controls
- WUE Settings
- WUE Analyze Stats
- Scatter Plots
- Advanced Settings
- Using WUE Analyze Live!
Using 3D tables
Folder Structure


About
Pleasure!! I am a software developer
Detail-oriented Software Developer with professional experience in both Backend and frontend development. I am adeveloper in Python language-> Django, Flask, Angular,SQLite, PostgreSQL, javascript and typescript.
Looking for an opportunity to work in a challenging position combining my skills in Software Engineering, which provides professional development, interesting experiences and personal growth.
Future plan: venture React //
Experience
- Developed bus booking web with lipa na mpesa app
- Tools: Python-django, JavaScript, and postgresql.
Projects
This is an app that allows user to log in post their blogs, comments and subscribe
- Tools: Django, HTML, CSS, Bootstrap, postgresql, Heroku
- Register/login to the web app(with OAuth-based Google Sign-In).
- A user can view the most recent posts..
- View and comment the blog posts on the site..
- A writer can create a blog from the application and update or delete blogs I have created.
This is an app that allows the user to peruse my photos and see each descption
- Tools: Django, HTML, CSS, Bootstrap, postgresql, Heroku
- Register/login to the web app(with OAuth-based Google Sign-In).
- Users can click on a single photo to expand it and also view details of the photo.
- Users can search for different categories of photos.
- Users can view photos based on location they were taken.
This an app that allows users to search for repositories from different username
This is an Instagram app
Competence
Languages and Databases
Libraries
Frameworks
Other
Education
Nairobi, Kenya
Certificate in: Profesional Software Development
- Prep-prep => HTML, CSS & JavaScript
- Prep => JavaScript, Boostrap, jQuery
- Core => Angular, Python-Flask and Django (Database)
Courseworks:
Nairobi, Kenya
Deploma: Diploma in Flight Dispatch and Airport Operations
- Weight and balance
- Aircraft General Knowledge
- Airport operations
- Customer service
- Computer packages
Courseworks:


People: David Boyne
Components (All)
Areas (All)
Tweets
Last Week
David Boyne
- Fri, Oct 29, 2021 - All of this is Open source and if you are interested in learning more, reach out or come join our community. https://t.co/9fqHoZ9JU0 With AsyncAPI spec and tools we believe we can help our community document, discover, and build better event driven applications.
- Fri, Oct 29, 2021 - Also, I'm working on a feature idea at the moment that gives people examples of using the studio for the first time. If you have no idea what @AsyncAPISpec is, this stuff can hopefully help and help you explore different protocols and real-world examples. https://t.co/LrQkBq8C5v
- Fri, Oct 29, 2021 - As we have WebSocket support, @smoyac came up with the idea of cross-collaboration of your files with your team. Imagine editing files together in real-time and seeing these changes in the studio 😍 https://t.co/qTIIlkJ2tD
- Fri, Oct 29, 2021 - Here @fmvilas shows us you can still use your editor of choice whilst getting all the benefits of our studio locally. We use WebSockets to manage communication between files. Edit in VSCode and See your changes in real-time in the studio 😍 https://t.co/4gIyu0PNrG
- Fri, Oct 29, 2021 - If you like to see your AsyncAPI visually you can use our visualizer that will show you how your application is connected. Shows you how to publish or subscribe from your application. https://t.co/XlxyXfWA4Y
- Fri, Oct 29, 2021 - You can write/edit your AsyncAPI file in the browser and see file render in our html docs as you go. https://t.co/fAWo2begQW
- Fri, Oct 29, 2021 - Over at @AsyncAPISpec we have been working on a new Studio that allows you to build and explore your AsyncAPI files. This is the initial release and we hope to be adding more ideas/modules in the future. https://t.co/aMUL2Gkis3 Some features documented below 👇 https://t.co/1NDNvsdMXn
- Fri, Oct 29, 2021 - @leeerob Would love to understand more benefits and patterns using URL imports vs npm packages. I guess one I can think of is the ability to update packages/widgets using url imports, without the need to update packages / build your website?
- Thu, Oct 28, 2021 - For example, pick your favourite lib/tool/framework. Just start from the top and work your way down, you will come across all sorts of patterns and wonderful (and not so wonderful) things!
- Thu, Oct 28, 2021 - One of the best things about working with open source code full time is the amount of stuff I'm learning. New patterns, designs, architectures, packages, and more! I said it before, but if you want to learn new things, literally just go to GitHub and start reading code 📖
- Wed, Oct 27, 2021 - I love the innovation here. https://t.co/rlAsqMMrT2 https://t.co/NtuXzNBvbh
- Tue, Oct 26, 2021 - HTTP requests are a stream of events from request to response. This is how I visualize them in my head 👇 I'm exploring building a new tool that allows us to create API's with graph nodes and streams. Connect nodes and get a real API in return... https://t.co/XOxy3BxGkI
- Tue, Oct 26, 2021 - reduce all things. Seriously it's my favourite function by far. Also this visual from @codingyuri is great! https://t.co/Gjk5n0bWwD
- Mon, Oct 25, 2021 - Over at @AsyncAPISpec @fmvilas has been playing around with Spec's first approach for building event-driven applications. In theory, it allows us to: • Define spec • Just focus on business logic • Profit Check out the video 👇 https://t.co/YuxkjdKJhJ
Last Month
David Boyne
- Fri, Oct 22, 2021 - This is just an initial thought of how I think @AsyncAPISpec can help us in the Serverless world. I believe the spec can be used to help describe and visualize our events/architecture. Most things in AWS are event-driven. There is huge value to documenting the systems we build https://t.co/mXIc6F8eZs
- Thu, Oct 21, 2021 - I've been playing around with flow diagrams for Event systems recently, but here is a model for HTTP. Here is an example of an idea where you can use blocks to create mock endpoints. Just POC but you could pipe blocks into each other...🤔 Just a thought 🤣 https://t.co/rlIOpL0Or7


The University of Toronto, as one of the top education institutes in the world, leads the way in the field of artificial intelligence, and it has Geoffrey Hinton’s Machine Learning Group – the first of the three world-leading forces in the field of deep learning. However, undergraduate students seldom have the opportunity of getting in touch with the scholars from the Machine Learning Group, or getting exposure to leading technology in machine learning. This has created a disconnection between the undergraduate students and top scholars in machine learning. UTMIST aims to clear the mist by demystifying artificial intelligence technology, which is the most trendy technology nowadays. As a student organization focused on machine learning research, UTMIST is to establish a close connection between the undergraduate students and top academic resources at U of T. University of Toronto Machine Intelligence Student Team (UTMIST) is an officially certified student organization within the University of Toronto. Our mission is to let more people get to know about artificial intelligence, “Clear the mist”!
Abhishek Moturu
Abhi Mahadevan
Ahmed Abdulkadir
Vicky Chen
Claire Dalkie
Devansh Ranade
Dorje Kongtsa
Litos Li
Harvey Fang
Charlie Chen
Isabella Mckay
Jacob Kelly
Jane Illarionova
Jianing Li
Jin Zhou
Johnny Ye
Lily Zhang
Rain Shen
Lisa Li
Malhar Shah
Matthieu Chan Chee
Michal Fishkin
Colin Li
Rob Liu
Rupert Wu
Ruiyao Li
Shrey Jain
Shubhra Bedi
Shuyi Wang
Sheldon Huang
Siyan Zhao
Sophie Zhang
Teng Tu
Theo Wu
Willy Hu
Jenny Wu
Steven Liu
Steven Zhao
Winnie Xu
Xi Yan
Cindy Zhang
Richard Xu
Raina Wang
Rex Fang
Alina Wei
Zach Trefler
Justin Yuan
Zitian Wu
Zoe Chen


public class BasicProgressBarUI extends ProgressBarUI
| Modifier and Type | Class and Description |
|---|---|
class |
BasicProgressBarUI.ChangeHandler
This class should be treated as a "protected" inner class.
|
| Modifier and Type | Field and Description |
|---|---|
protected Rectangle |
boxRect
Used to hold the location and size of the bouncing box (returned
by getBox) to be painted.
|
protected ChangeListener |
changeListener |
protected JProgressBar |
progressBar |
| Constructor and Description |
|---|
BasicProgressBarUI() |
| Modifier and Type | Method and Description |
|---|---|
static ComponentUI |
createUI(JComponent x) |
protected int |
getAmountFull(Insets b,
int width,
int height)
This determines the amount of the progress bar that should be filled
based on the percent done gathered from the model.
|
protected int |
getAnimationIndex()
Gets the index of the current animation frame.
|
int |
getBaseline(JComponent c,
int width,
int height)
Returns the baseline.
|
Component.BaselineResizeBehavior |
getBaselineResizeBehavior(JComponent c)
Returns an enum indicating how the baseline of the component
changes as the size changes.
|
protected Rectangle |
getBox(Rectangle r)
Stores the position and size of
the bouncing box that would be painted for the current animation index
in
r and returns r . |
protected int |
getBoxLength(int availableLength,
int otherDimension)
Returns the length
of the "bouncing box" to be painted.
|
protected int |
getCellLength()
Returns the width (if HORIZONTAL) or height (if VERTICAL)
of each of the indivdual cells/units to be rendered in the
progress bar.
|
protected int |
getCellSpacing()
Returns the spacing between each of the cells/units in the
progress bar.
|
protected int |
getFrameCount()
Returns the number of frames for the complete animation loop
used by an indeterminate JProgessBar.
|
Dimension |
getMaximumSize(JComponent c)
Returns the specified component's maximum size appropriate for
the look and feel.
|
Dimension |
getMinimumSize(JComponent c)
The Minimum size for this component is 10.
|
protected Dimension |
getPreferredInnerHorizontal() |
protected Dimension |
getPreferredInnerVertical() |
Dimension |
getPreferredSize(JComponent c)
Returns the specified component's preferred size appropriate for
the look and feel.
|
protected Color |
getSelectionBackground()
The "selectionBackground" is the color of the text when it is painted
over an unfilled area of the progress bar.
|
protected Color |
getSelectionForeground()
The "selectionForeground" is the color of the text when it is painted
over a filled area of the progress bar.
|
protected Point |
getStringPlacement(Graphics g,
String progressString,
int x,
int y,
int width,
int height)
Designate the place where the progress string will be painted.
|
protected void |
incrementAnimationIndex()
Sets the index of the current animation frame,
to the next valid value,
which results in the progress bar being repainted.
|
protected void |
installDefaults() |
protected void |
installListeners() |
void |
installUI(JComponent c)
Configures the specified component appropriately for the look and feel.
|
void |
paint(Graphics g,
JComponent c)
Delegates painting to one of two methods:
paintDeterminate or paintIndeterminate.
|
protected void |
paintDeterminate(Graphics g,
JComponent c)
All purpose paint method that should do the right thing for almost
all linear, determinate progress bars.
|
protected void |
paintIndeterminate(Graphics g,
JComponent c)
All purpose paint method that should do the right thing for all
linear bouncing-box progress bars.
|
protected void |
paintString(Graphics g,
int x,
int y,
int width,
int height,
int amountFull,
Insets b) |
protected void |
setAnimationIndex(int newValue)
Sets the index of the current animation frame
to the specified value and requests that the
progress bar be repainted.
|
protected void |
setCellLength(int cellLen) |
protected void |
setCellSpacing(int cellSpace) |
protected void |
startAnimationTimer()
Starts the animation thread, creating and initializing
it if necessary.
|
protected void |
stopAnimationTimer()
Stops the animation thread.
|
protected void |
uninstallDefaults() |
protected void |
uninstallListeners()
Removes all listeners installed by this object.
|
void |
uninstallUI(JComponent c)
Reverses configuration which was done on the specified component during
installUI . |
contains, getAccessibleChild, getAccessibleChildrenCount, update
protected JProgressBar progressBar
protected ChangeListener changeListener
protected Rectangle boxRect
public static ComponentUI createUI(JComponent x)
public void installUI(JComponent c)
ComponentUI
ComponentUI
instance is being installed
as the UI delegate on the specified component. This method should
completely configure the component for the look and feel,
including the following:
LayoutManager
on the component if necessary.
PropertyChangeListener
on the component in order
to detect and respond to component property changes appropriately.
installUI
in class ComponentUI
c
- the component where this UI delegate is being installedComponentUI.uninstallUI(javax.swing.JComponent)
,
JComponent.setUI(javax.swing.plaf.ComponentUI)
,
JComponent.updateUI()
public void uninstallUI(JComponent c)
ComponentUI
installUI
. This method is invoked when this
UIComponent
instance is being removed as the UI delegate
for the specified component. This method should undo the
configuration performed in installUI
, being careful to
leave the JComponent
instance in a clean state (no
extraneous listeners, look-and-feel-specific property objects, etc.).
This should include the following:
uninstallUI
in class ComponentUI
c
- the component from which this UI delegate is being removed;
this argument is often ignored,
but might be used if the UI object is stateless
and shared by multiple componentsComponentUI.installUI(javax.swing.JComponent)
,
JComponent.updateUI()
protected void installDefaults()
protected void uninstallDefaults()
protected void installListeners()
protected void startAnimationTimer()
stopAnimationTimer()
protected void stopAnimationTimer()
startAnimationTimer()
protected void uninstallListeners()
public int getBaseline(JComponent c, int width, int height)
getBaseline
in class ComponentUI
c
- JComponent
baseline is being requested forwidth
- the width to get the baseline forheight
- the height to get the baseline forNullPointerException
- if c
is null
IllegalArgumentException
- if width or height is < 0JComponent.getBaseline(int, int)
public Component.BaselineResizeBehavior getBaselineResizeBehavior(JComponent c)
getBaselineResizeBehavior
in class ComponentUI
c
- JComponent
to return baseline resize behavior forNullPointerException
- if c
is null
JComponent.getBaseline(int, int)
protected Dimension getPreferredInnerHorizontal()
protected Dimension getPreferredInnerVertical()
protected Color getSelectionForeground()
protected Color getSelectionBackground()
protected int getCellLength()
setCellLength(int)
,
JProgressBar.isStringPainted()
protected void setCellLength(int cellLen)
protected int getCellSpacing()
setCellSpacing(int)
,
JProgressBar.isStringPainted()
protected void setCellSpacing(int cellSpace)
protected int getAmountFull(Insets b, int width, int height)
public void paint(Graphics g, JComponent c)
paint
in class ComponentUI
g
- the Graphics
context in which to paintc
- the component being painted;
this argument is often ignored,
but might be used if the UI object is stateless
and shared by multiple componentsComponentUI.update(java.awt.Graphics, javax.swing.JComponent)
protected Rectangle getBox(Rectangle r)
r
and returns r
.
Subclasses that add to the painting performed
in this class's implementation of paintIndeterminate
--
to draw an outline around the bouncing box, for example --
can use this method to get the location of the bouncing
box that was just painted.
By overriding this method,
you have complete control over the size and position
of the bouncing box,
without having to reimplement paintIndeterminate
.r
- the Rectangle instance to be modified;
may be null
null
if no box should be drawn;
otherwise, returns the passed-in rectangle
(if non-null)
or a new rectanglesetAnimationIndex(int)
protected int getBoxLength(int availableLength, int otherDimension)
paintIndeterminate
to get the width (if the progress bar is horizontal)
or height (if vertical) of the box.
For example:
boxRect.width = getBoxLength(componentInnards.width, componentInnards.height);
availableLength
- the amount of space available
for the bouncing box to move in;
for a horizontal progress bar,
for example,
this should be
the inside width of the progress bar
(the component width minus borders)otherDimension
- for a horizontal progress bar, this should be
the inside height of the progress bar; this
value might be used to constrain or determine
the return valueavailableLength
SwingUtilities.calculateInnerArea(javax.swing.JComponent, java.awt.Rectangle)
protected void paintIndeterminate(Graphics g, JComponent c)
paintDeterminate(java.awt.Graphics, javax.swing.JComponent)
protected void paintDeterminate(Graphics g, JComponent c)
paintIndeterminate(java.awt.Graphics, javax.swing.JComponent)
protected void paintString(Graphics g, int x, int y, int width, int height, int amountFull, Insets b)
protected Point getStringPlacement(Graphics g, String progressString, int x, int y, int width, int height)
public Dimension getPreferredSize(JComponent c)
ComponentUI
null
is returned, the preferred
size will be calculated by the component's layout manager instead
(this is the preferred approach for any component with a specific
layout manager installed). The default implementation of this
method returns null
.getPreferredSize
in class ComponentUI
c
- the component whose preferred size is being queried;
this argument is often ignored,
but might be used if the UI object is stateless
and shared by multiple componentsJComponent.getPreferredSize()
,
LayoutManager.preferredLayoutSize(java.awt.Container)
public Dimension getMinimumSize(JComponent c)
getMinimumSize
in class ComponentUI
c
- the component whose minimum size is being queried;
this argument is often ignored,
but might be used if the UI object is stateless
and shared by multiple componentsDimension
object or null
JComponent.getMinimumSize()
,
LayoutManager.minimumLayoutSize(java.awt.Container)
,
ComponentUI.getPreferredSize(javax.swing.JComponent)
public Dimension getMaximumSize(JComponent c)
ComponentUI
null
is returned, the maximum
size will be calculated by the component's layout manager instead
(this is the preferred approach for any component with a specific
layout manager installed). The default implementation of this
method invokes getPreferredSize
and returns that value.getMaximumSize
in class ComponentUI
c
- the component whose maximum size is being queried;
this argument is often ignored,
but might be used if the UI object is stateless
and shared by multiple componentsDimension
object or null
JComponent.getMaximumSize()
,
LayoutManager2.maximumLayoutSize(java.awt.Container)
protected int getAnimationIndex()
protected final int getFrameCount()
protected void setAnimationIndex(int newValue)
repaint
method
is invoked.newValue
- the new animation index; no checking
is performed on its valueincrementAnimationIndex()
protected void incrementAnimationIndex()
setAnimationIndex(int)
Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2015, Oracle and/or its affiliates. All rights reserved.


Drag the books you wish to purchase from the SHELF into the CART.
(I know, it doesn't look like a shelf or a cart, just use your imagination)
SHELF
CART
Quantity:
0
Subtotal:
$0.00
The draggable items are keyboard accessible.
Press the Tab and Shift+Tab keys to switch between items.
Press the Enter key to initiate drag.
Mouse users can drag and drop the desired item as usual.


You can write regular markdown here and Jekyll will automatically convert it to a nice webpage. I strongly encourage you to take 5 minutes to learn how to write in markdown - it'll teach you how to transform regular text into bold/italics/headings/tables/etc.
When \(a \ne 0\), there are two solutions to \(ax^2 + bx + c = 0\) and they are $$x = {-b \pm \sqrt{b^2-4ac} \over 2a}.$$
Here is some bold text
Here's a useless table:
| Number | Next number | Previous number |
|---|---|---|
| Five | Six | Four |
| Ten | Eleven | Nine |
| Seven | Eight | Six |
| Two | Three | One |
How about a yummy crepe?
Here's a code chunk:
var foo = function(x) {
return(x + 5);
}
foo(3)
And here is the same code with syntax highlighting:
var foo = function(x) {
return(x + 5);
}
foo(3)
And here is the same code yet again but with line numbers:
{% highlight javascript linenos %} var foo = function(x) { return(x + 5); } foo(3) {% endhighlight %}
You can add notification, warning and error boxes like this:
{: .box-note} Note: This is a notification box.
{: .box-warning} Warning: This is a warning box.
{: .box-error} Error: This is an error box.


eFIRST-AID
-
EFA 11.00 AM, Today
Hello, I am EFA - Your Virtual 'First Aid' Assistance.
-
You 11.01 AM, Today
yo
-
EFA 11.01 AM, Today
Hi, how are you today?
-
You 11.01 AM, Today
my friend slashed by Jason, and bleeding so much!
-
EFA 11.01 AM, Today
Choose from these informations below


This chapter describes the various useful facilities which enable complex extensions to be built using MLisp programs.
The facilities for binding command key sequences to functions are very general in nature. When Emacs is accepting commands from the terminal, it translates those commands into Emacs functions. Every command key sequence will result in the execution of one function---either MLisp, a macro, an autoloaded function or some wired-in code.
A keymap is the entity that tells Emacs what to do when a given key is typed by the user. It will either indicate that a function should be called, or that another keymap should be used to obtain another character in a multicharacter command sequence.
For every buffer, there are two routes to follow for command key decoding; the global keymap and the buffer's local keymap . Command key sequences that are defined by the global keymap may be used from any buffer in Emacs, while command key sequences defined in local keymaps may only be used from buffers that associate with the keymap.
When accepting commands, Emacs makes transitions across the two trees of keymaps as though they were finite state automata. Keymaps can be regarded as look-up tables to make transitions across these automata. Each table contains 256 entries---one entry for each eight-bit ASCII character.
Keymaps have names which are entered into the function name-space. This means that it is quite legal to execute a keymap as a function. If you do this, the next key sequence input by Emacs will be translated starting with the executed keymap. If you execute more than one keymap, the last keymap executed is used to start the keymap translation.
Several functions and variables can be used to manipulate keymaps. These include the following:
(define-keymap name)
This function explicitly declares a keymap and initialises its contents. The keymap's name is entered into the function name-space. Once the keymap has been declared in this way, it can be explicitly nominated as a local or global keymap.
(use-global-map name)
Uses the nominated keymap as the global keymap for all subsequent command input. name must be an existing keymap.
(use-local-map name)
Uses the nominated keymap as the local keymap for the current buffer. Any previous local keymap association is removed (though the keymap itself will not be destroyed).
current-local-keymap
This variable contains the name of a buffer's current local keymap. The name it contains may be used with a use-local-map function.
default-global-keymap
This variable contains the default global keymap that Emacs initialises and uses when it starts up. It contains the standard command key sequences plus any global alterations the user has made.
Functions may be bound to any arbitrary key sequence using the functions described as follows:
(bind-to-key name keys)
Makes a global binding to a function. The function binding will be usable from any buffer. The function name must have already been declared in the function name-space. keys can be an arbitrary sequence of characters used to access the function. The following example binds the function set-mark to the Select key:
(bind-to-key "set-mark" "select)")
If keys is a character constant, then the binding is entered into the current global keymap. If keys is a string, then enough keymaps are automatically generated to define the entire path to the function. Automatically generated keymaps have names of the form auto-defined-keymap-n, where n is a sequence number.
If the key sequence specified is a control sequence, it must be a valid ISO control sequence. For example, the key sequence ESC-Select is not a valid ISO control sequence because it generates two consecutive ESC characters. However, Emacs allows you to bind commands to such sequences by providing the convert-key-string function. convert-key-string will convert a control sequence according to Emacs' control-string processing rules to a valid ISO control sequence. For example, to bind the unset-mark function to the ESC-Select key sequence, use the convert-key-string function as follows:
(bind-to-key "unset-mark"
(concat
""
(convert-key-string "select)")
)
)
(local-bind-to-key name keys)
Defines a local binding to a function. The binding is entered into the current buffer's local keymap. Character and string keys parameters are treated as described under bind-to-key. If a buffer does not have a local keymap, an error is reported.
(global-binding-of keys)
Returns a string containing the name of the function defined by the keys string using the current global keymap.
(local-binding-of keys)
Returns a string containing the name of the function defined by the keys string using the current buffer's local keymap.
(remove-all-local-bindings)
Removes all the local bindings in the current buffer's local keymap. The local keymap itself is not destroyed.
(remove-binding keys)
Removes the association of a function to a command key sequence from the global keymap.
(remove-local-binding keys)
Removes the association of a function to a command key sequence from the local keymap.
Emacs provides a comprehensive database management system.
The key components of the database system are database search-lists. These are ordered lists of database files. When data is to be fetched from a database search-list, Emacs scans all the files in the list until it either finds a key match, or the list is exhausted. When Emacs writes data to a database search-list, the data is always inserted into the database at the top of the specified search-list.
You can use any text as the key for a database entry. However keys used in the MLisp-library should conform to the rules for file names and not use upper case letters.
Certain optimisations are made to ease the problems of multiple invocations of Emacs using the same library files. Library files in a database search-list will always be closed and re-opened between each library operation. This may slow down library searches, but it does ensure that data in the library is not cached inside Emacs, so that other Emacs users can access the library.
Database files are of two types: read-only, and read-write. You control which type of access is required by specifying parameters to Emacs. If a database file is protected against writing, read-only access will be granted if possible.
Emacs uses the following database search-lists:
info
This list is used by the INFO subsystem to provide pages of information. The INFO database describes which files are accessed.
language
This list is used by the language modes C Mode and Bliss Mode as the source of language construct templates. The templates supplied with Emacs are found in the file EMACS_LIBRARY:EMACSLANG.TLB. During initialisation of the language subsystems, your language template file SYS$LOGIN:LANGUAGE-TEMPLATES.TLB is added to the search-list so that you can override the system templates with your own templates.
MLisp-library
This list provides database access to stored MLisp programs. All the distributed MLisp functions are stored in the file EMACS_LIBRARY:EMACSLIB.TLB. This file is visible in the search-list. To provide for user extensions and customisations, Emacs will also add the file SYS$LOGIN:EMACSLIB.TLB (if it exists) to the search-list during initialisation.
describe
This search-list is used by the describe-command, describe-variable and Help functions. The files in the list contain the Emacs help database. This search-list can grow as new packages are added into the running Emacs.
subr-names
This search-list is used by the describe-word-in-buffer function as the source of one-line information about words. It contains the supplied quick-information database files and the user's SYS$LOGIN:SUBRNAMES.TLB database if it exists.
The following commands are provided to manipulate database search-lists and to access the data contained in them:
(extend-database-search-list dbname dbfile access)
This command adds the database file specified to the nominated database search-list. The file's writeability is checked and a flag is set to indicate the file's type. If the database search-list does not exist, it is created. If the file already exists in the search-list, it is not added again. access is an optional argument containing access flags. The flags are specified as a bit-mask with the following meaning:
(remove-database dbname dbfile)
Removes the dbfile database file from the dbname database search-list. No error message is generated if the file does not exist. The database search-list will remain even if the last file is removed.
(list-databases)
Creates a buffer called Database list and inserts the names and file names of all the database search-lists. This buffer is then displayed in a window.
(put-database-entry dbname key)
Inserts the current buffer into the first library in the designated database search-list using the specified key. You cannot use put-database-entry on a read-only database. Completion is enabled for both the database search-list name and the key.
(fetch-database-entry dbname key)
Fetches the contents of the designated module and inserts the data into the current buffer at dot. Dot remains in the same place. Completion is enabled for both the database search-list name and the key. If the key does not exist, an error is generated.
(fetch-help-database-entry dbname keys)
Performs the special operation of fetching help from a VMS HELP library and formats it in the same way as the DCL HELP command. The location of the key must be a help library. The formatted help text is inserted into the buffer at dot. Dot remains in the same place. An error is reported if the keys are not found. The keys are defined as a space-separated list of up to 8 keys which access the required help text. fetch-help-database-flags controls the amount of information fetched from the entry.
fetch-help-database-flags
Controls the amount of help text that is inserted into the current buffer when the fetch-help-database-entry function is executed. It contains a bit-mask which can take the following values:
The default value of the bit-mask is 7, meaning that all the information is returned.
Emacs has a set of functions for controlling subprocesses. These processes are created by Emacs and can execute any shell to accept commands. You designate a name for each subprocess and use this name when you want to refer to it.
The number of concurrently running subprocesses is limited only by the resources available to you.
(start-process process-name)
Creates the named subprocess. process-name must not already exist. The current process is changed to the newly-created process.
(kill-process process-name)
Deletes the named subprocess. If the name is null, the current process is deleted. When the process has actually terminated, the process termination procedure will be called. After the termination procedure has finished executing, the process name will be removed from the process name-space.
(list-processes)
Displays a buffer containing the name and state of each existing process. A time value is also displayed; this is set to the time the last state-transition occurred. The associated output buffer, input and output procedures are also displayed.
The possible process states include:
(pause-process process-name)
Allows a given process to be temporarily suspended by sending a VMS SUSPEND request to it. A paused process will remain paused until it is explicitly resumed or killed.
(resume-process process-name)
Resumes a process which has been paused with pause-process.
(force-exit-process process-name reason)
Causes the image running in the specified process to be terminated with the specified status code. Processes that are not running in user mode will not be affected by the exit until they resume execution in user mode. If the process is not running an image, the force exit will be issued on the next image run in the process.
(set-process-termination-procedure process-name function)
Associates an Emacs function with a process. The associated function will be called when the process terminates (not when an image exits). When the associated function is called, the current process is temporarily set to the associated process.
(current-process-name)
Returns a string containing the current process name. This name will be either the name of the last created process, the name of the process which was a target of the set-current-process function, or the name of the associated process for functions called as a result of process input, output or termination.
(set-current-process process-name)
Changes the current process to the process with the specified name. If you change the current process name in an associated input, output or termination function, the effect will only last for the invocation of that function.
The following functions exist to make input and output to and from processes convenient.
For output, the data produced by the process can be inserted into a buffer associated with the process. This provides a convenient way for you to see the output. If, however, some processing of the output is required, then an Emacs function can be automatically called to obtain the output when it is available and perform the required processing.
The functions available for output include:
(set-process-output-buffer process-name buffer-name)
Associates a buffer with a process. When output is available from the process, it is inserted at the end of the buffer. The screen will be updated if the buffer is associated with a window.
If the number of characters exceeds the maximum for the process, characters will be deleted from the beginning of the buffer. This feature protects you from creating huge process buffers.
(set-process-output-procedure process-name function)
Associates an Emacs function with a process. This function will be called once for every line that is produced by the process. It is assumed that the function will obtain the output line and process it in some way. When the procedure is called, the current process is temporarily set to the process that produced the output line.
(process-output process-name)
Returns the next output line from the process.
For input, the user makes lines of input available to the process. If the process does not require input, an error is generated. To allow for co-ordination of input, the following functions are provided:
(set-process-input-procedure process-name function)
Associates an Emacs function with the process. When the process requests some input, the designated function is called. It is assumed that the function will provide some input to the process. During the call of the associated function, the current process is temporarily set to the associated process.
(send-string-to-process process-name input-line)
Sends some input to the designated process. If that process is not requesting input, an error is generated.
(wait-for-process-input-request process-name)
Suspends Emacs execution until the designated process requests some input. Keyboard input will also cause this function to return to prevent Emacs from becoming wedged. When a process asks for input, the function returns 1; otherwise, it returns 0, indicating that the user pressed a key on the keyboard.
Minor modes are used to alter the way Emacs performs an operation. All minor modes are independent of each other and of the selected major mode. The statuses of some minor modes are displayed in the mode lines for each window. Each minor mode is controlled by a variable that can be turned on or off.
The following minor modes are defined by Emacs:
Auto-fill Mode
This mode allows you to type text endlessly without worrying about the width of your screen. Line separators are inserted as required to prevent lines from becoming too long.
Auto-fill Mode is controlled by setting the variable right-margin. When an attempt is made to insert a word character passed the right margin, auto-filling is invoked.
Checkpoint Mode
Checkpoint Mode protects you from system crashes by periodically saving the buffers you are working with. Whenever you visit a file, checkpointing is enabled if the variable checkpoint-frequency is non-zero.
Checkpointing for individual buffers is also controlled by the buffer-specific variable current-buffer-checkpointable.
Journal Mode
Journal Mode protects you from system crashes by writing a journal of all the changes that are made to modified buffers. When you visit a file, journalling is automatically enabled if the variable journal-frequency is non-zero.
Journalling for individual buffers is controlled by the buffer-specific variable current-buffer-journalled.
Replace Mode
Replace Mode causes ordinary printing characters to replace existing text rather than be inserted. For example, if dot is in front of the B in FOOBAR, then in Replace Mode, typing a G changes it to FOOGAR, instead of making it FOOGBAR as usual.
This mode is controlled with variable replace-mode.
Abbreviation Mode
Abbreviation Mode allows you to define abbreviations that automatically expand as you type them. For example, am might expand to Abbrev mode. The abbreviations also may depend on the active major mode.
This mode is controlled by the variable abbrev-mode.
Read-only Mode
Read-only Mode allows you to protect the data in a buffer from being altered. When Read-only Mode is enabled, attempts to insert characters into the buffer are ignored and cause the bell to be sounded.
This mode is controlled by the variable read-only-buffer.
As with most things in Emacs, the information in the mode line is customisable. A buffer-specific variable mode-line-format exists for this purpose. mode-line-format contains a format string which governs the way that the mode line information is displayed. It contains literal text and embedded format effectors. The literal text will be displayed in the mode line as it is typed, while the format effectors will be expanded with the appropriate information. You normally alter the default value of this variable (default-mode-line-format) so that when a new buffer is created, it displays your customised mode line immediately.
The general form of the format effectors is %nx. n is the width of the string to be inserted and causes truncation or padding on the right. x is one of the letters in the following list:
a
Inserts the string Abbrev if Abbreviation Mode is on, otherwise it inserts nothing.
b
Inserts the current buffer's name.
c
Inserts the string Checkpoint if checkpointing is generally enabled and also enabled for the current buffer, otherwise it inserts nothing.
f
Inserts the current file name for buffers associated with files, or [No File] for scratch buffers.
h
Inserts the string <n< if the horizontal position of the window on the current buffer does not include column one. n indicates by how many characters column one is offset from the left-hand side of the window.
j
Inserts the string Journal if journalling is enabled for the buffer, otherwise nothing is inserted.
m
Inserts the value of the buffer-specific variable mode-string. This variable defines the major mode for the buffer.
M
Inserts the value of the global variable global-mode-string which defines the name of the currently running subsystem.
p
Inserts the position of dot in the current buffer as a percentage. If dot is at the beginning of the buffer, the string Top is inserted. If dot is at the end of the buffer, the string Bottom is inserted.
r
Inserts the string Overstrike if Replace Mode is currently enabled.
R
Inserts the string Readonly if Read-only Mode is currently enabled.
*
Inserts a asterisk if the current buffer has been modified since it was last written to disk, otherwise it inserts nothing.
[ and ]
Inserts zero or more square brackets depending on the depth of recursive editing. One bracket is inserted per level when the recursive edit depth is less than 5. When the edit depth is 5 or greater, the string [n] is inserted, where n is the recursive edit depth.
The default value of mode-line-format is:
%[%hBuffer: %b%* File: %f %M (%m%c%r%a) %p%]
The effects of all the Emacs commands which parse words or balance parentheses are controlled by syntax tables . Each ASCII character is represented by one entry in each syntax table. Each buffer has a syntax table associated with it. The default syntax table is called global-syntax-table. The name of the current syntax table (the syntax table associated with the current buffer) may be accessed through the variable current-buffer-syntax-table, and this table may be changed either by setting the variable, or by using the function use-syntax-table.
To alter a syntax table, the function modify-syntax-entry is provided. This command takes a single string argument which describes the attributes to be applied to the specified characters as follows:
· The first character is one of the following:
w
A word character, as used by such functions as forward-word and case-word-capitalize.
Space
A character with no special interpretation.
(
A open parenthesis. Typical candidates for this type are the characters (, [ and.
Characters of this type also have a matching closing parenthesis specified which appears as the second character of the parameter to modify-syntax-entry.
)
A close parenthesis. Typical candidates for this type are the characters ), ] and. Characters of this type also have a matching open parenthesis specified which appears as the second character of the parameter to modify-syntax-entry.
"
A double-quote character. The C string delimiters " and ' are usually given this class.
\
A prefix character, like \ in C.
· The second character of the string is the matching parenthesis if the first character is of the open or close parenthesis type. If you specify that ( is a left parenthesis matched by ), you should also specify that ) is a right parenthesis matched by (.
· The third character, if a , indicates that the characters described by this syntax entry begin a comment.
· The fourth character, if equal to , indicates that the character described by this syntax entry ends a comment.
· If either the beginning or ending comment sequence is two characters long, then the fifth character provides the second character of the comment sequence.
· The sixth and following characters specify which characters are described by the entry; a range of characters can be specified by using the sequence specifier a-b, where aand b are ASCII characters and a is less than b. -- can be described if it appears as the sixth character.
Attribute entries that are not relevant should be spaces.
For example:
(modify-syntax-entry "w -")
makes - behave as a word character;
(modify-syntax-entry "(] [")
makes [ behave as a left bracket which is matched by ].
The function list-syntax-tables is useful for finding out the names of all the syntax tables known to Emacs. Use dump-syntax-table to dump the contents of a syntax table. This function is very useful when trying to discover why a syntax table is not working as expected.


The {@link oaj.assertions} package in Juneau is a powerful API for performing fluent style assertions.
It is used throughout the REST client and server APIs for performing inline assertions on REST requests and responses.
| // Create a basic REST client with JSON support and download a bean.
| MyBean bean = RestClient.create()
| .json5()
| .build()
| .get(URI)
| .run()
| .assertStatus().asCode().is(200)
| .assertHeader("Content-Type").isMatches("application/json*")
| .getContent().assertValue().asString().isContains("OK")
| .getContent().as(MyBean.class);
- The REST API is described later in the documentation.
The assertions API is designed to be used in both code (as it's done in the REST APIs) or for standalone
use in unit tests.
The {@link oaj.assertions.Assertions} class provides various static methods for invoking assertions on a variety
of object types for simplified unit testing.
- {@link oaj.assertions.Assertions}
- {@link oaj.assertions.Assertions#assertAny(Object) assertAny(T)}
- {@link oaj.assertions.Assertions#assertArray(Object[]) assertArray(E[])}
- {@link oaj.assertions.Assertions#assertBean(Object) assertBean(V)}
- {@link oaj.assertions.Assertions#assertBeanList(List) assertBeanList(List)}
- {@link oaj.assertions.Assertions#assertBoolean(Boolean) assertBoolean(Boolean)}
- {@link oaj.assertions.Assertions#assertBooleanArray(boolean[]) assertBooleanArray(boolean[])}
- {@link oaj.assertions.Assertions#assertByteArray(byte[]) assertByteArray(byte[])}
- {@link oaj.assertions.Assertions#assertBytes(byte[]) assertBytes(byte[])}
- {@link oaj.assertions.Assertions#assertBytes(InputStream) assertBytes(InputStream)}
- {@link oaj.assertions.Assertions#assertCharArray(char[]) assertCharArray(char[])}
- {@link oaj.assertions.Assertions#assertCollection(Collection) assertCollection(Collection)}
- {@link oaj.assertions.Assertions#assertComparable(Comparable) assertComparable(T)}
- {@link oaj.assertions.Assertions#assertDate(Date) assertDate(Date)}
- {@link oaj.assertions.Assertions#assertDoubleArray(double[]) assertDoubleArray(double[])}
- {@link oaj.assertions.Assertions#assertFloatArray(float[]) assertFloatArray(float[])}
- {@link oaj.assertions.Assertions#assertIntArray(int[]) assertIntArray(int[])}
- {@link oaj.assertions.Assertions#assertInteger(Integer) assertInteger(Integer)}
- {@link oaj.assertions.Assertions#assertList(List) assertList(List)}
- {@link oaj.assertions.Assertions#assertLong(Long) assertLong(Long)}
- {@link oaj.assertions.Assertions#assertLongArray(long[]) assertLongArray(long[])}
- {@link oaj.assertions.Assertions#assertMap(Map) assertMap(Map)}
- {@link oaj.assertions.Assertions#assertObject(Object) assertObject(T)}
- {@link oaj.assertions.Assertions#assertOptional(Optional) assertOptional(Optional)}
- {@link oaj.assertions.Assertions#assertReader(Reader) assertReader(Reader)}
- {@link oaj.assertions.Assertions#assertShortArray(short[]) assertShortArray(short[])}
- {@link oaj.assertions.Assertions#assertString(Object) assertString(Object)}
- {@link oaj.assertions.Assertions#assertStringList(List) assertStringList(List)}
- {@link oaj.assertions.Assertions#assertThrowable(Throwable) assertThrowable(V)}
- {@link oaj.assertions.Assertions#assertThrown(Snippet) assertThrown(Snippet)}
- {@link oaj.assertions.Assertions#assertVersion(Version) assertVersion(Version)}
- {@link oaj.assertions.Assertions#assertZonedDateTime(ZonedDateTime) assertZonedDateTime(ZonedDateTime)}
Assertions have 3 categories of methods:
- Testing methods (isX methods)
- Transform methods (asX methods)
- Configuration methods (setX methods)
| import static org.apache.juneau.assertions.Assertions.*;
| import static org.apache.juneau.assertions.AssertionPredicates.*;
|
| // Check the contents of a string.
| assertString("foo, bar")
| .asSplit(",")
| .asTrimmed()
| .isHas("foo", "bar");
|
| // Extract a subset of properties from a list of beans and compare using Simplified JSON.
| List<MyBean> myListOfBeans = ...;
| assertBeanList(myListOfBeans)
| .asPropertyMap("a,b")
| .asJson().is("[{a:1,b:'foo'}]");
|
| // Perform an arbitrary Predicate check against a bean.
| MyBean myBeans = ...;
| assertBean(myBeans)
| .is(x -> isValidCheck(x))
|
| // Check that a list of strings has less than 10 entries and the first
| // 3 entries are [foo, bar*, null] using assertion predicates.
| List<String> myListOfStrings = ...;
| assertStringList(myListOfStrings)
| .asSize().isLt(10)
| .asFirst(3)
| .isEach(eq("foo"),match("bar*"),isNull())
|
| // Check that an exception is thrown and is the specified type and has the specified message.
| assertThrown(()->myBean.runBadMethod())
| .exists()
| .isExactType(RuntimeException.class)
| .asMessage().is("foo");
Testing methods (isX methods) perform an assertion on the specified value and throws a {@link java.lang.AssertionError} if
the test fails. Otherwise, the method returns the original assertion object to allow you to chain the command.
| // Test a string.
| assertString(myString)
| .isNotNull() // Perform test and returns original FluentStringAssertion.
| .isNotEmpty(); // Perform test and returns original FluentStringAssertion.
Transform methods (asX methods) allow you to convert assertions of one type to another type or to convert the tested value to
some other form wrapped in another assertion.
| // Customize the behavior of an assertion.
| assertString(myString)
| .asString() // Converts to a FluentIntegerAssertion.
| .isLt(100) // Runs test and returns original FluentStringAssertion.
| .asUc() // Converts string to uppercase and returns a new FluentStringAssertion.
| .isContains("FOO"); // Runs test and returns original FluentStringAssertion.
Configuration methods (setX methods) allow you to tailor the behavior of assertions when they fail. They always return the same assertion object.
Transformed assertions inherit the configurations of the created-by assertions. Configuration methods start with set.
| // Customize the behavior of an assertion.
| assertString(myString)
| .setMsg("My string was null. Value was {VALUE}.") // Custom error message when error occurs.
| .setOut(myPrintWriter) // Print error message to a separate writer.
| .setThrowable(MyAssertionThrowable.class) // Throw a customized assertion exception.
| .isNotNull();
The following shows the class hierarchy for the {@link oaj.assertions.IntegerAssertion IntegerAssertion} class showing the general
design pattern for assertion classes:
- {@link oaj.assertions.Assertion Assertion} - Base class for all assertion objects containing common configuration methods.
- {@link oaj.assertions.FluentAssertion FluentAssertion<R>} - Parent class for all fluent assertions.
- {@link oaj.assertions.FluentObjectAssertion FluentObjectAssertion<T,R>} - Tests and transforms for general POJOs.
- {@link oaj.assertions.FluentComparableAssertion FluentComparableAssertion<T extends Comparable,R>} - Tests and transforms for Comparables.
- {@link oaj.assertions.FluentIntegerAssertion FluentIntegerAssertion<R>} - Tests and transforms for Integers.
- {@link oaj.assertions.IntegerAssertion IntegerAssertion} - Assertion that returns itself.
In the design, the "Fluent" classes (e.g. {@link oaj.assertions.FluentIntegerAssertion}) allow you to specify the object
that gets returned when the test method is executed. When used in the RestClient class for example, the return
object is the {@link oajrc.RestResponse} object so that you can perform multiple fluent operations against that object.
The "Normal" classes (e.g. {@link oaj.assertions.IntegerAssertion}) are simply subclasses of the fluent equivalent
which return the assertion itself, meaning the test method returns the original {@link oaj.assertions.IntegerAssertion}
so that multiple tests can be performed per assertion.
For more information about the capabilities of the Assertions API, refer to the methods on the {@link oaj.assertions.Assertions} methods
above.


| 257 | (A) | the vernacle after veronyke vaspasyane it callede |
| 251 | (C) | The vernacle aftur veronyca . vaspasyan hit called |
| 252 | (D) | þe vernicle aftir veronica vaspasian hit callid |
| 252 | (E) | ¶ The vernycle after veronica . waspasyan it callyd |
| (Ex) | ---- no text ---- | |
| 257 | (L) | þe veronycle after veronyk waspasian hit called |
| 249 | (P) | þe vernykyłł after vernyk waspasian it called |
| 249 | (U) | The Vernicle after Veronike / Vespasian it called |
| (V) | ---- no text ---- |


Postgres Performance Lessons
At least once a week I receive an email from someone to the effect of “We’re running Postgres and we’re growing, we’ve started hitting bottlenecks and performance issues and we’re hoping you can point us in the right direction.” I’ve responded to many of these emails, done training seminars on how to diagnose your database performance as an application developer, and spoken at conferences around this. I’ve now compiled all of this knowledge to help you go from feeling like your database is a black box to getting a feel for overall health, to where to dig in and find quick wins when it comes to performance improvements.
This has been compiled into a series of write-ups which are now available for you to purchase via email. These write-ups are delivered 1 per week to allow you time to dig into each and apply what you know–optimizing along the way. In addition to the content itself you’ll have the ability to reach out and follow-up directly for further instruction via email.


the and ERV-Fc that sequences for with al., from were are viral The this these between sequence was genomes species virus Gag (Figure consensus data found host genome using which retroviral history {background ERV This all lineages protein transmission viruses amino endogenous gag two cross-species have mammalian evolutionary exogenous acid generated Figure ferret loci recombination env human margin multiple DOI:http://dx.doi.org/./eLife.. analysis based each phylogenetic phylogeny proteins related {border-style events including one used —source also px;} residues #ffffff;} Sciences diversity evolution leukemia most murine phylogenies retrovirus within However, Pol States United evidence likely not other present retroviruses their where Academy National World could distinct more rate sequences. well can conserved included observed several BLAST Env age but dog genomic region spread than elements identified indicate known least million regions similar structural three ./eLife..Figure LINK These Virology among analyses both carnivore colored consistent different due during gene independent involved lineage many molecular motifs revealed single time trees For HERV-H New ancient coding domain domains endogenization genes indicated indicates information into may performed replication site species, such while would years (Bénit ERV-Fc. MLV Thus, alignment. clade closely common either encode extant interspecies majority membrane monophyletic our primate produced sequencing shown some structure substitution HERV-W Old Similar alignment alignments ancestor ancestors approximately capsid distribution divergence envelope examined following gammaretroviruses genetic global individual involving its life locus mammals matrix modern nucleotide number pol pol, px; relationship role species. study those transmissions {font-family America America./pnas. DNA ERV-Fc, HIV- been canonical colonization complex contrast, data, depicted essential estimates first font-size full-length gag, given harbor high hosts identified, indicating low model mutations natural only patterns previously primary record scores sequences, significant studies then there they very when B). ERV, ERV-W Genome LTR MYA N-terminal Our Pathogense./journal.ppat. Such acids allowed binding canine case clades contain corresponding double; early encoded example, form functions further genome. genomes, giant group has hits include instances late long millions monkey motif per position possessed primates provide reconstructed reflect relationships respectively. results reverse same subunits target virus. whose (Jern Based Finally, Gag, LTRs ORF ORFs Spring active after ancestral border-color border-width branch calculated chimeric cleavage contained continued date described emergence estimate every forms gamma-like genome, genomes. had highly identity immunodeficiency important initial integration large lineage. lines loci. maintain moloney new novel numerous old oldest open pattern possess potential predicted produce replicating retrovirus. share solid; squirrel surface vertical virus, viruses. {font-style {font-weight & (Mortuza (as (e.g. A). All Bayesian CA, Diehl Drafting EMBO ERV-Fc- Furthermore, Great Indeed, Journal MYA, Oligocene Onee./journal.pone. Press Sequencing Similarly, Smith account acquisition additional analysis, another appear approach article. association bold carnivores. cellular clock comprised conservation courier; critical database databases derived design, differences diversity, dogs em; eutherian event except exogenously extracted fact feature ferrets, findings formed function functional fusion geographic hosts. identify implemented incongruencies jumps lineages, lineages. long-term mammals. monkeys mouse nature neutral occurred often order over packaging part penalty place polyprotein portion primates, provided provides pt;} published query reading reconstruct reconstructions relatedness reported resulted resulting retroviruses, revising rise second selection significantly similarity sites speciation specific split). subsequent supertree supplement thousands times type utilized varied view years, years. —figure


Music's stars turn out for the American Music Awards
Some of the biggest names in the music industry turned out for Sunday night's American Music Awards.
Some of the biggest names in the music industry turned out for Sunday night's American Music Awards.