Commit to Yourself
This may get hard, but it's going to be worth it! I hearby promise to trust the process, and reach out when I need help! I promise to be patient with myself, and not rush if I don't understand something.
It's been a journey - trust me, I didn't want to use the word "journey"...but truly, that's what it's been. I've been learning computer programming from the fabtastic Skillcrush, mixed with w3 schools, and lots and lots and lots of repetition.
I've been learning how I learn, and slowly but surely becoming more and more confident with each week. (Not each day - there are far too many ups and downs to say each day I've improved!)
This page (and probably more) will hold all of my Javascript discoveries. I hope you enjoy and are able to gain some value from it!
This may get hard, but it's going to be worth it! I hearby promise to trust the process, and reach out when I need help! I promise to be patient with myself, and not rush if I don't understand something.
You can make slideshows, pop ups, and sick animations! And much more obviously.
Computational Thinking is the term used to describe what it means to think like a computer. And Computational Thinking is all about using the specific and unique capabilities of computers to solve problems. Humans have the ability to think in gray areas and feelings and make complex connecions. Computers think in terms of math and logic, 0s and 1s. Computers have a skillset, and learning to think like one (simpler) will help you know how to use it better!
Computers are a funny contradiction because they are both incredibly powerful and unbelievably simple. But in order to access their power, you first need to understand their limitations. (Learning to think like a programmer.) The main limitation is that computers really only understand zeros and ones. This is really different from how our brains work. Javascript and other programming languages are like the translators between your human thoughts and what the computer understands. So what I need to do is learn how to simplify my thinking (LOL OKAY) so I can begin to speak to the computer in terms it can understand. (WILL I FINALLY OVERCOME MY CHRONIC OVERTHINKING? IS THIS THE ANSWER?)
Before writing any code, these priciples will help you think through your problem in a computational way.
The process of breaking down one big problem into smaller and smaller ones until all the problems are small and easy enough to solve. Ask yourself questions to the problems you're trying to solve. This reminds me of depression and when you're trying to defeat it - break down tasks, no matter how small already into even smaller tasks. Put one foot on the floor, the other, stand up, walk to the bathroom, etc. Work up momentum!
After breaking down your problems into smaller problems, think to see if any of your smaller problems have ny commonalities, or if you can use similar methods to solve them. Just like when you learn how something works, you may be able to repeat the process for similar things. Rinse and repeat!
In abstraction, the goal is to omit specific details and to focus on the general patterns (OOH this is like when starting work on a drawing or painting - abstracting it helps see the bigger picture, the bigger shapes that contain the smaller shapes and details!) In other words, my task is to solve a very simplified version of the problem you're trying to solve. In a party invitation example, you're going to send out invitations.  But there are certain things you don't need to know in order to send out your test invitation. You don't need to know the date, time or place. It's just a test! Just making sure it works is most important.
In reality, writing an algorithm is much simpler than it sounds (sweet). It just means writing a series of instructions that explain how to solve a problem. Although algorithms are used a ton in computer programming, any set of instructions - A recipe, a knitting pattern, a set of instructions for how to assemble your IKEA dresser - are all algorithms we encounter every day.
Decomposition is the process of breaking a big problem (challenge or issue) into smaller and smaller parts until the problems are small enough that you can easily solve them.
Then just focusing on each of the smaller problems until the bigger problem is solved.
Let's say we're throwing a party. There are many details to consider! Where and when will it be? Who will you invite? What will you serve? What will you wear?!
Here, the big problem to solve is planning this party, and the invitations, venue, menu, music, all of those are smaller problems inside of a bigger problem. For now let's focus on sending out those invitations.
Let's pretend we're working on the programming for an eCommerce site for a boutique. The client wants to be able to sort all the items by type (tops, skirts, pants, dresses, outerwear, and accessories), as well as by size, by color and by price. She also wants to build a custom checkout page, create pop-ups for all of her specials, and have a slide show on each product page.
Woah! That's a lot. Rather than trying to solve all the problems at once, maybe just start with the sorting task.
Abstraction is a close cousin of decomposition. Once you've broken your problem into smaller parts, you can ask - which parts of the problem are absolutely necessary for me to solve it? And which can I leave out? Abstraction makes it possible for you to focus on what's necessary. In computer programming, less is more!
If you wanted to, you could go crazy with your invitations! What if you sent them all by balloon? Or carrier pigeon? And what if, when you opened up the invitation, it played a song and spouted confetti?
You could do all of these, but at the end of the day, the task is much simpler. You need to get the date, time, and other essential information to your guests, and then they need to RSVP. Maybe. That's IT. Everything else is just unnecessary details!
As you're thinking through how to sort all the items in the boutique, you may be tempted into thoughts like: "What if the site can show tops AND skirts at the same time?" or "What if the tops could be sorted by sleeve length?!
The challenge is - that's overkill! And all you really need to do is sort the things your client has listed. Start with the bare minimum that you need to do - it'll be complicated enough.
It is possible that your method for solving ONE small problem could solve another one. This is where you look at all the small problems and see if there are any commonalities.
To figure out the best way to send your invitation to LOTS of people, test out how it works with one person first. That way, you can find out if there is a glitch with your e-invitation service, or how long it takes to prep and send something by snail mail.
There are so many ways you need to sort the items in the boutique! Before trying to do it for everything, start by doing it for one of the properties - say color. Doing this will help you learn important lessons that you can apply to filtering by other properties.
Once you have broken your BIG problem down into smaller problems, looked for similarities between the problems, removed all extraneous details...it's time for Algorithm Writing!
In reality, writing an algorithm is much simpler than it sounds. It just means writing a series of instructions that explain how to solve a problem. Although algorithms are used a TON in computer programming, an algorithm doesn't need to be written in code to be an algorithm. In fact, any set of instructions - a recipe, a knitting pattern, a set of directions for how to assemble your IKEA dresser - those are all examples of algorithms that we encounter every day.
Let's say you've decided to send your invitations by Evite. Your algorithm could read something like this:
Once you've figured out how to sort by color, you can write an algorithm that you can apply to your other filters. Its instructions could read something like this (but of course the actual instructions would be in code:)
But then of course the actual instructions would be in javascript, like this.
Time to get a computer to make a peanut butter and jelly sandwich!
Here's the issue - the computer knows basically...nothing. It doesn't know what bread is, what peanut butter is, what jelly is, or how to spread the peanut butter, how to use a knife or even what a knife is.
We'll start with the four priciples of computational thinking.
Let's pick one of those problems and see what we can do.
First, let's look for some patterns. Are there any aspects of the list of actions we made that are repetitive?
Yup! Opening the peanut putter jar and jelly jar, and spreading the peanut butter and spreading the jelly.
If we figure these out for peanut butter, then we can use the same methods for jelly.
If you were to turn a PB & J into a math equation, it would be something like this: PB&J = Peanut Butter + Jelly + Bread
But of course, putting peanut butter, jelly and bread together doesn't necessarily make a sandwich. There are lots of other details and assumptions that we're leaving out. For example, what kind of bread are we using? Is it gluten free? What about the peanut butter? Is it creamy or crunchy? And tell me about the jelly. Strawberry, jams or preserves...
There's lots to think about, but not right now because we are going to solve a simplified version of the problem. And in fact, that is the hardest thing about abstraction - leaving out all of those details.
There's one more thing abstraction can help us with here: checking our assumptions. Assumptions are tricky.
We can't assume the computer knows anything. But in abstraction, you sometimes have to make some assumptions in order to solve one small part of the problem. So while trying to think through one part of the peanut butter and jelly sandwich - like how to spread peanut butter or jelly - you may want to make some assumptions like:
Writing out assumptions like these will help you figure out how to solve the spreading problem.
For example, if we assume the computer knows what a knife is, we no longer need to define it right this second, which make our problem a bit easier to solve. Then you can focus on defining the knife later, when it's time to do that.
Now it's finally time to write that algorithm to teach the computer how to make a peanut butter and jelly sandwich. And by algorithms, I just mean that you need to write out instructions for the comupter for how to make a peanut butter and jelly sandwich.
Let's make a cat clock!
Today, we're going to plan the logic of the most basic form of this algorithm.
As we think through the LOLCat Clock, we'll think about the four priciples: Decomposition, Abstraction, Pattern Recognition and Algorithm Writing
When it's time to write the algorithm, there's one thing we need to know about: Logic.
Let's say we want our LOLCat Clock to say "Good morning!" in the morning and "Good day!" any other time of day. Our instructions might read something like this:
Meaning if "this clause" is true then do "X", or if it's not morning, IF "this clause" is not true then do "Y".
This is pretty close to how logic is expressed by computers. Only instead of saying "IF NOT", computers say "ELSE".
IF it's morning, THEN say "good morning!" ELSE say " "good day!" Where ELSE means any time it's not morning.
Along with logic, computers also really like numbers. So even though a computer might not know what morning is, it does know numerical representations of time.
So instead of asking whether it's morning or not, you may find it's easier just to ask if the time is less than 12, like this:
IF the time is less than 12pm, THEN say "good morning!"
Which you could also express using the "less than" sympbol.
IF the time is < 12 pm then say "good morning!"
Computers LOVE logic, which means they love it when you give them instructions like, "IF X THEN do Y and ELSE do Z."
IF and ElSE are common computer keywords found in every programming language, so learn to love 'em! They also love numbers - adding them, comparing them, you name it! So whenever possible, translate your logic into numbers.
We gonna b working on this throughout the whole class! So get comf. An LOLCat Clock is a website that delivers a different LOLCat-themed message to a user depending on what time of day the user visits the site.
As we start to think through the logic of the LOLCat clock, keep the Four Priciples of Computational Thinking in mind:
In this first part, we'll focus on the logic needed to make the clock work. The key principles at work for your LOLCat Clock are IF and ELSE.
In order to work properly, the LOLCat website needs to deliver a different message to the user depending on what time it is. To start, if it's morning, the LOLCat will say something like "Good morning!" If it's NOT morning it will say something like, "Good day!"
If we were to write out instructions for how to do that we might write something like this:
This is pretty close to how logic is expressed by computers. But instead of saying "IF NOT" computers prefer another keyword: ELSE. So the computer would express the same idea like so:
In addition to logic, another thing that computers like to do when it comes to logic is compare numerical values.
In order for the computer to know what afternoon is, you need to define it using numerical terms. First you need to know what time it is, which is expressed as numbers. Then you can find out whether the time is equal to, greater than, or less than the time value that you've set to be the morning. To set that, you can write something like this:
A computer would express this same direction like this:
For example, if it's 9am the LOLCat might say "Good morning!" If it's afternoon it could say "Good Afternoon!"
Today, our job is to plan the logic of this algorithm, and to think through the four principles of computational thinking as you do.
Flowcharts are a great way to plot out algorithms, especially if it needs to output different results along the way. And they often use a standard set of styling conventions:
A start/stop to mark the start and stop of the algorithm which is a rounded rectangle.
Process block for an instruction or command which is a rectangle.
A decision diamond for either a yes or no, which is a diamond.
An input/output parallelogram for either input the computer receives or output the computer provides.
Circles to connect one point in the algorithm to another, if needed. (If theres a connection point or turn that needs to be made in order to show it's bypassing or connecting to another point.)
Arrows indicate the way the algorithm flows.
Whether you're making your flowchart in a computer or by hand, using these conventions will help to communicate what's happening at each stage.
Here's an example of a logical statement followed by its flowchart translation:
Pseudocode is a way of simplifying your instructions so that they read more like code. It's a middleground to help you understand the problem better and the way you can go about solving it. Of course, pseudocode won't work on a computer, but it helps guide you towards that.
 Because they are very similar to the types of keywords you'll use when you write code.
Variables are stand-ins for some value, just like they were in algebra in school: x = y + 8, if y = 2, solve for x
But unlike algebra where the answer is always a number, in programming variables can be different things - like words or even chunks of code.
Also, unlike algebra, in programming, the value of variables can change depending on where you are in the script. They may start as one value, and end up a totally different value later!
Let's say you're making a clock, and you need a variable for the current time of day. The value is changing constantly! But the variable remains the same.
Now let's look at a variation of our LOLCat clock and try writing it out in pseudocode:
INPUT computer finds out what time it is
STORE time in the TIME variable
IF TIME < 12pm
OUTPUT message: "Good morning!!"
ELSE
OUTPUT message: "Good day!"
We may not understand what all of these terms mean right now, but just think about how you might use them as they will help us translate our pseudocode into JavaScript.
The first thing you need to know is that you need to tell your computer when a statement or instruction is done. Similar to when you stick in a period or make a new paragraph - computers are so literal that you have to spell it out for them. Which means that if you create a loop or a function or an if/else statement you have to tell the computer when that statement is DONE. And you do that by writing either STOP or END. Whichever one works for you!
Computers often think in terms of "if x happens, then do y, if not do Z." In pseudocode, you represent this idea using IF, THEN, ELSE.
IF time is known THEN
OUTPUT message: "Good day, mate!"
ELSE
OUTPUT "I'm not sure what time it is. Good day anyway!"
STOP
It's not uncommon for some parts of code to require an input in order to run, and to create an output as a result. This idea comes up a lot in writing functions, something you'll be doing all the time in JavaScript. You can express inputs and outputs in pseudocode like this:
INPUT time
IF time is known
IF time is before noon THEN
OUTPUT message: "Good morning!"
ELSE IF time is after evening THEN
OUTPUT message: "Good evening!"
ELSE
OUTPUT message: "Good afternoon!"
STOP
ELSE
OUTPUT "I'm not sure what time it is. Good day anyway!"
STOP
STORE is a pseudocode term that tells your computer when it needs to store or save a value. Let's say you had a form field where you could input your name, and then it would output a message with your name on it. In between inputting and outputting your name, you want to save your name.
The pseudocode for telling the computer to store something would look like this:
INPUT name "Jane Doesitall"
STORE name
OUTPUT message: "Hello [name]! Welcome to our website!"
You can also use STORE if you want a certain value to change. Like, say you always have a favorite dress, but which dress is your favorite depends on what season it is. Your pseudocode might look something like this:
STORE favorite dress
STORE season
IF season IS summer
favorite dress IS blue dress with spaghetti straps
ELSE IF season IS fall
favorite dress IS maroon dress with three-quarter sleeves
ELSE IF season IS winter
favorite dress IS grey sweater dress
ELSE IF season IS spring
favorite dress IS cap-sleeved purple dress
STOP
When writing pseudocode - not to mention JavaScript - you may want to format your lines using indentation.
Indentation helps you to be able to see what's in your pseudocode more clearly. It's not necessary, but it's super helpful - not only for you, but for other people reading your code.
Leslie is on her way to work, and she really wants an almond milk latte. She's also doesn’t have a whole lot of extra time, so she makes a plan: she’ll go by her favorite coffee shop, Joe’s, and if they’re too busy, then she’ll swing by her second favorite spot, Mighty Bean.
If we were to plot out this text as instructions, it would look something like this:
As a flow chart, it would look something like this:
And as pseudocode, it would read like this:
START
IF Joe's is not too busy THEN
Go to Joe's
OUTPUT Get an almond milk latte from Joe's!
ELSE IF Joe's is too busy THEN
Go to Mighty Bean.
IF Mighty Bean isn't too busy THEN
OUTPUT Get an almond latte.
ELSE
Go to work
OUTPUT drink work coffee.
STOP
There are some key things to notice here:
Of course, you can write your pseudocode however you want! These are just some guidelines you can use to help keep your concepts straight.
There's one more thing to mention here: what if this pseudocode was using variables?
There are two items in the above pseudocode that could be expressed as variables:
The value for each of these changes depending on what stage you're at in the process.
Here's the same pseudocode as above, only now with our two variables:
STORE coffeeshop.
STORE beverage AS "almond milk latte".
START
coffeeshop = Joe's.
IF coffeeshop is not too busy THEN
Go to coffeeshop.
OUTPUT Get a beverage from coffeeshop!
ELSE IF coffeeshop is too busy THEN
coffeeshop = Mighty Bean.
Go to coffeeshop.
IF coffeeshop isn't too busy THEN
OUTPUT Get beverage.
ELSE
Go to work
beverage = "work coffee."
OUTPUT get beverage.
STOP
The variables are declared at the top using the pseudocode word STORE. In one case - coffeeshop - the value isn't assigned until the instructions get going. beverage, however, has been assigned the value "almond milk latte" - a value retains until almost the end of the code.
It may feel silly to declare variables like this, but next week you'll be writing real JavaScript. And then, you'll really have to!
An object can be anything - a dog, a candy bar, a house. What we use to identify that thing are its properties.
A House, for example, usually has properties like:
And so on.
(Of course actual houses have a lot more properties than this, but we're abstracting here!)
As many properties as houses generally share, many of them are quite different! Some are single story, some are multi-story, some are wood, some are brick. But as many variations as there are, we still understand the concept of a house and the properties it usually has. So like, there are usually always, bedrooms, bathrooms, a roof, an exterior etc. But there can be more of course.
Objects in JavaScript work in a similar way. You could have an object for a political candidate in an election, who could have properties like name and number of votes. The values for those properties may change based on who the candidate is, but the candidate object remains the same.
Political candidate Robin (Object = Political Candidate Property = name Value = Robin) 50 votes (Property = votes Value = 50)
Let's say you were to write out a house object in pseudocode. It could look something like this:
OBJECT House
PROPERTY exterior
PROPERTY paint color
PROPERTY roof
PROPERTY stories
PROPERTY bedrooms
PROPERTY bathrooms
PROPERTY other rooms
When you call a new instance of that object, you can give it new values - like the kind of exterior, the kind of roof, the number of stories, and the number of different kinds of stories.
Functions are like mini algorithms that exist within your larger algorithim.
The purpose of a function is to group related actions into little bundles, so you can both organize your code and repourpose it.
To write out a function, start with the function keyword and follow it by the name of your function. For example, if I were explaining to the computer howt to spread peanut butter I would write:
FUNCTION spread
take knife
dip into peanut butter
grab bread
place knife with peanut butter on the bread
move knife back and forwards so that peanut butter is transferred to the bread
Then, any time I need to read the function, I'll just write:
RUN FUNCTION spread
Sometimes functions need inputs in order to work. An input for a function is called a parameter.
If your function requires parameters, then you need to let the computer know. In this instance, the spread function requires both bread and something spreadable, like peanut butter. So I'll write that out by the name of the function:
FUNCTION spread WITH bread & peanut butter
take knife
dip into peanut butter
grab bread
place knife with peanut butter on the bread
move knife backwards and forwards so that peanut butter is transferred to the bread
Now we've fixed the first issue, but it still only works for peanut butter.
To make this function spread agnostic, we'll replace the "peanut butter" with the term "breadspread":
FUNCTION spread WITH bread & breadspread
take knife
dip into peanut butter
grab bread
place knife with peanut butter on the bread
move knife backwards and forwards so that peanut butter is transferred to the bread
"Breadspread" now works as a variable in our function called "spread."
so NOW, if I want the computer to spread some jelly, I'll tell the computer that "breadspread" is equal to jelly before calling the "spread" function:
And then this way you can change the breadspread variable to any type of spread you'd like:
breadspread = nutella
breadspread = butter
breadspread = vegan butter
breadspread = hummus
And no matter what, the computer will know what to do!
In addition to having INPUTS, sometimes functions have OUTPUTS. OUTPUTS are what the fuction returns to you when it's done running.
In this bread spreading example, you'd expect it to hand you a piece of bread with some spread on it, right?
But remember that computers don't know anything. So if you want it to give you some bread and bread spread, you have to specify it!
That's called an OUTPUT, which you can specify using the OUTPUT or RETURN keyword:
FUNCTION spread with bread & breadspread
take knife
dip into breadspread
grab bread
place knife with breadspread on the bread
move knife backwards and forwards so that breadspread is transferred to the bread
RETURN bread with breadspread
Now you've got some bread and bread spread!
Like those spreading instructions? If they're part of a peanut butter and jelly sandwich object, then they're a method. A method works like a function, but it's a property of an object. That's why they get a special name.
And just like functions, you have to call them to make them work.
Functions often require inputs and produce outputs.
We actually learned a little bit about this when we worked on creating our peanut butter and jelly sandwich instructions:
The same way of thinking can apply to all different kinds of objects, like the House object we've been practicing with.
Variables are stand-ins for some value (words, numbers, or chunks of code) like in algebra: x = y + 8, if y = 2, solve for x
With a clock, the value of the variable could change, but the variable would stay the same, making it easier to call out in code.
INPUT computer finds out what time it is
STORE time in the TIME variable
IF TIME < 12pm
OUTPUT message: "Good morning!!"
ELSE
OUTPUT message: "Good day!"
Obvious, but just make sure you put START at the beginning, and STOP at the end. Theeannks
IF x happens, THEN do y, ELSE (if not/otherwise) do z.
It's common to need to input information in order for code to run, and for something (output) to return.
INPUT time
IF time is known
IF time is before noon THEN
OUTPUT message: "Good morning!"
ELSE IF time is after evening THEN
OUTPUT message: "Good evening!"
ELSE
OUTPUT message: "Good afternoon!"
STOP
ELSE
OUTPUT "I'm not sure what time it is. Good day anyway!"
 Welcome to our website!"
You can also use STORE if you want a certain value for a variable to change. Like, say you always have a favorite dress, but which dress is your favorite depends on what season it is. Below, favorite dress & season are both variables with changing values. Your pseudocode might look something like this:
STORE favorite dress
STORE season
IF season IS summer
favorite dress IS blue dress with spaghetti straps
ELSE IF season IS fall
favorite dress IS maroon dress with three-quarter sleeves
ELSE IF season IS winter
favorite dress IS grey sweater dress
ELSE IF season IS spring
favorite dress IS cap-sleeved purple dress
STOP
Another previous example. Here, coffeeshop is one variable with a value that changes, and beverage is another variable with a value that stays the same.
STORE coffeeshop.
STORE beverage AS "almond milk latte".
START
coffeeshop = Joe's.
IF coffeeshop is not too busy THEN
Go to coffeeshop.
OUTPUT Get a beverage from coffeeshop!
ELSE IF coffeeshop is too busy THEN
coffeeshop = Mighty Bean.
Go to coffeeshop.
IF coffeeshop isn't too busy THEN
OUTPUT Get beverage.
ELSE
Go to work
beverage = "work coffee."
OUTPUT get beverage.
STOP
You could have an object for a political candidate in an election who could have properties like name and number of votes. The values for those properties may change based on who the candidate is, but the candidate object remains the same.
Political candidate Robin (Object = Political Candidate Property = name Value = Robin) 50 votes (Property = votes Value = 50)
A house object could look like this:
OBJECT House
PROPERTY exterior
PROPERTY paint color
PROPERTY roof
PROPERTY stories
PROPERTY bedrooms
PROPERTY bathrooms
PROPERTY other rooms
The house (object) could have a paint color (property) that's blue (value)
Functions are like mini algorithms that exist within your larger algorithim.
This allows you to repurpose your code.
FUNCTION spread
take knife
dip into peanut butter
grab bread
place knife with peanut butter on the bread
move knife back and forwards so that peanut butter is transferred to the bread
Then, anytime I need to run the function, I'll write:
RUN FUNCTION spread
However, this only works with peanut butter - we need it to work with bread and also other spreads, like jelly.
An input for a function is called a parameter.
So...it is the input (that contains a variable (that contains a value)) for the mini algorithim within your algorithim.
If your function requires parameters (i.e. inputs which are values, or variables that house values), you need to let the computer know by saying what your parameter (Input>Variable>Value) is next to the name of the function:
FUNCTION spread WITH bread & peanut butter
take knife
dip into peanut butter
grab bread
place knife with peanut butter on the bread
move knife backwards and forwards so that peanut butter is transferred to the bread
Now we need to make this work for more than just peanut butter! We'll do that by making a variable (with a changeable value that could be peanut butter or jelly or anything else)
To make this FUNCTION (a mini algorithm within the larger algorithm) spread more agnostic (interchangable?) we'll replace the "peanut butter" value with the term/variable "breadspread":
FUNCTION spread WITH bread & breadspread
take knife
dip into peanut butter
grab bread
place knife with peanut butter on the bread
move knife backwards and forwards so that peanut butter is transferred to the bread
This will allow us to use different values for the breadspread variable!
We have to tell the computer what we want returned to us, otherwise it will run and not give anything back.
FUNCTION spread WITH bread & breadspread
take knife
dip into peanut butter
grab bread
place knife with peanut butter on the bread
move knife backwards and forwards so that peanut butter is transferred to the bread
RETURN bread with breadspread
Here, bread is a value as there is only one of it, and breadspread is a variable because it can be interchanged.
breadspread = jelly
RUN FUNCTION spread WITH bread & breadspread
When functions (mini algorithms within a larger algorithm) are apart of an object (An object "House" holds properties like "paint color, roof, bedrooms (which are variables, that can hold values)" etc. - Method is on a property level. Imagine a drop down menu for the roof with an algorithm/function for how the roof is constructed - instead of calling it a function, it's called a method!), they are called Methods.
If the FUNCTION spread (the algorithm within the larger sandwich algorithm) is apart of a peanut butter and jelly sandwich object, then they're a Method. A method works just like a funtion, but it's a property of an object.
And just like functions, you have to call on them to get them to work.
Soooo I guess an object can/is technically a holder of algorithms? We shall seeee
This same way of thinking can apply to all different kinds of objects, like the house object example.
OBJECT House
PROPERTY exterior
PROPERTY paint color
PROPERTY roof
PROPERTY stories
PROPERTY bedrooms
PROPERTY bathrooms
PROPERTY other rooms
Now say that you wanted to make a function for weatherproofing the exterior of the house using pseudocode. You might write something like this:
FUNCTION
INPUT house, house exterior, and weatherproppfing brand
Use weather proofing to weatherproof the house exterior
OUTPUT weatherproofed house
STOP
This function has some important elements:
Now for something that's a little tricky about functions. You'd think that just writing it out would mean that the computer will actually do something with it. But since computers don't know what to do, you actually have to tell it explicitly to run the function! This is called calling a function. (Seems like css classes/ids)
Although, if you think about it, it actually makes sense! Just because I hand you a recipe it doesn't mean you're going to bake the cookies. But if I hand you a recipe and ORDER you to bake the cookies...
To run the function for building the house, you need to call it somewhere in your pseudocode. It could be a standalone like this:
RUN FUNCTION Weatherproof house WITH INPUTS House 1, aluminum, Bob's Allweather
STOP
If you think about it, weatherproofing is one of those things that all houses really need. Since it's something that's required for a house, it almost sounds like it could be a property of a house!
In fact, functions can exist inside of objects. And when they do, they technically become properties! They also get a new name: methods. Methods work just like functions, only they are attached to ojects. In pseudocode, you could write that out as something like this:
OBJECT House
PROPERTY exterior
PROPERTY paint color
PROPERTY roof
PROPERTY stories
PROPERTY bedrooms
PROPERTY bathrooms
PROPERTY other rooms
FUNCTION Weatherproof house
INPUT house exterior, and weatherproofing brand
Use weatherproofing to weatherproof the house exterior
OUTPUT weatherproofed house
STOP FUNCTION
The section of FUNCTION Weatherproof house is a method.
Notice that Weatherproof house no longer uses House as an input - since it's part of the House object, it no longer needs it.
To run the method (a function (a mini algorithm) within an object), call it - and define the values you'd like to include as parameters! (Parameters are inputs in a function - inputs contain a value or variable that would contain a value.) In the example below, the exterior is aluminum and the weatherproofing brand.
RUN FUNCTION Weatherproof house with INPUTS aluminum, Bob's Allweather
Now that we've got the scoop on functions and methods, it's time for us to write one!


Enter the URL to the TSWA server. Examples:http://tswasrv or http://TFSMachine:8080/. The plugin will strip the last path (if any) of the URL when building URLs for change set pages and other pages.
If the field is empty then the plugin will try to build up a valid URL using the server URL. For instance if the server URL is https://server:8090 then the plugin will creates links such as https://server:8090/cs.aspx?cs=99, which is identical if the user entered https://server:8090 into this field.


Axioms
Here are the 5 axioms of the Balochi Yaggir script:
- The script must serve the Balochi language and not the other way around. No other language should be served.
- The alphabet and numbers must be exclusively Latin with additional common diacritical letters and symbols if necessary.
- Simplicity and ease of use. The script must be used for the broadest possible transcription of the Balochi sounds with the absolute minimum number of diacritical letters, symbols, and rules.
- Each letter of the alphabet must have a unique basic Balochi sound value. Every basic sound of the Balochi language must be exclusively represented by a unique letter of the alphabet. No digraphs, ligatures, or redundant letters are allowed.
- The spelling rules and conventions must conform, and in no way be in conflict with, the standard pronunciations and flow of the Balochi language.


Drone Based Aircraft Inspection
Log of all inspection flights
Sample
[Date of Test]
Overview Mode
Interactive Mode
Car
04-08-2018
Overview Mode
Interactive Mode
Car with damage
04-08-2018
Overview Mode
Interactive Mode
F-84F
04-11-2018
Overview Mode
Interactive Mode
F-84F with damage
04-11-2018
Overview Mode
Interactive Mode
C-130A
04-11-2018
Overview Mode
Interactive Mode
C-130A with damage
04-11-2018
Overview Mode
Interactive Mode


Class: JsonapiCompliable::Scoping::Paginate
- Defined in:
- lib/jsonapi_compliable/scoping/paginate.rb
Overview
Apply pagination logic to the scope
If the user requests a page size greater than MAX_PAGE_SIZE
, a
JsonapiCompliable::Errors::UnsupportedPageSize
error will be
raised.
Notably, this will not fire when the `default: false` option is passed. This is the case for sideloads - if the user requests “give me the post and its comments”, we shouldn't implicitly limit those comments to 20. BUT if the user requests, “give me the post and 3 of its comments”, we should honor that pagination.
This can be confusing because there are also 'default' and 'customized' pagination procs. The default comes 'for free'. Customized pagination looks like
class PostResource < ApplicationResource
paginate do |scope, current_page, per_page|
# ... the custom logic ...
end
end
We should use the default unless the user has customized.
Constant Summary
- MAX_PAGE_SIZE =
1_000
Instance Attribute Summary
Attributes inherited from Base
Instance Method Summary collapse
-
#apply ⇒ Object
Apply the pagination logic.
-
#apply? ⇒ Boolean
We want to apply this logic unless we've explicitly received the default: false option.
-
#apply_custom_scope ⇒ Object
Apply the custom pagination proc.
-
#apply_standard_scope ⇒ Object
Apply default pagination proc via the Resource adapter.
-
#custom_scope ⇒ Proc, Nil
The custom pagination proc.
Methods inherited from Base
Constructor Details
This class inherits a constructor from JsonapiCompliable::Scoping::Base
Instance Method Details
#apply ⇒ Object
Apply the pagination logic. Raise error if over the max page size.
30 31 32 33 34 35 36 37 |
# File 'lib/jsonapi_compliable/scoping/paginate.rb', line 30 def apply if size > MAX_PAGE_SIZE raise JsonapiCompliable::Errors::UnsupportedPageSize .new(size, MAX_PAGE_SIZE) else super end end |
#apply? ⇒ Boolean
We want to apply this logic unless we've explicitly received the default: false option. In that case, only apply if pagination was explicitly specified in the request.
44 45 46 47 48 49 50 |
# File 'lib/jsonapi_compliable/scoping/paginate.rb', line 44 def apply? if @opts[:default] == false not [page_param[:size], page_param[:number]].all?(&:nil?) else true end end |
#apply_custom_scope ⇒ Object
Apply the custom pagination proc
63 64 65 |
# File 'lib/jsonapi_compliable/scoping/paginate.rb', line 63 def apply_custom_scope custom_scope.call(@scope, number, size, resource.context) end |
#apply_standard_scope ⇒ Object
Apply default pagination proc via the Resource adapter
58 59 60 |
# File 'lib/jsonapi_compliable/scoping/paginate.rb', line 58 def apply_standard_scope resource.adapter.paginate(@scope, number, size) end |
#custom_scope ⇒ Proc, Nil
Returns the custom pagination proc
53 54 55 |
# File 'lib/jsonapi_compliable/scoping/paginate.rb', line 53 def custom_scope resource.pagination end |


JavaScript Quiz!
You will receive 25 points for each correct answer
You have 25 seconds for each question. If your answer is incorrect 25 seconds will be deducted from the time left
You will receive 25 points for each correct answer
You have 25 seconds for each question. If your answer is incorrect 25 seconds will be deducted from the time left


{% extends "icds_reports/mobile/base_mobile.html" %} {% load menu_tags %} {% load compress %} {% load hq_shared_tags %} {% load i18n %} {% block title %}{% trans "ICDS-CAS Mobile Dashboard" %}{% endblock %} {% block head %} {% compress css %} {% endcompress %} {% include 'analytics/analytics_js.html' %} {% include 'analytics/google.html' %} {% compress js %} {% endcompress %} {% comment %} Split up compression due to a weird js dependency bug that makes it not work without this. {% endcomment %} {% compress js %} {# only needed for importing location directive - not actually referenced by mobile dashboard #} {# only needed for importing awc report directive - not actually referenced by mobile dashboard #} {% endcompress %} {% include 'icds_reports/partials/shared_utility_services.html' %} {% include 'icds_reports/partials/shared_report_services.html' %} {# components #} {% include 'icds_reports/partials/shared_component_directives.html' %} {% compress js %} {# maps #} {% endcompress %} {% include 'icds_reports/partials/shared_report_directives.html' %} {% endblock head %} {% block body %}


I started using meth for energy and the feeling of sexual euphoria it initially gave me during sex. That was about 9 yrs ago. I would say that it was really mind expanding and sexually enhancing initially, but now it seems that 'the going up is not really worth the coming down' as the song says. Speed giveth and then taketh away! I can stay awake for 30-60 hrs. still, but now i feel totally exhausted, mentally drained, and really hate life for days after I stop 'tweaking'. Also, 'crank' causes a lot more side affects than it did 5+ years ago--I guess it's made with more poison, or I'm just getting to old for this s--t! It can and often gives me formication, aural hallucinations, blurry vision, and of course stomach problems. On the plus side, I have kept my weight the same for 10 years and even lost 5-10 lbs-but its not exactly a healthy diet aid.
I doubt anything I say would stop a tweaker or someone contemplating usage, but I have to say this drug really is a 'trickster' and it has kept me coming back for more-for nine years. I do not think I am below average in most ways: I am college educated, single, made over $25,000 last year, have never been arrested, and am not considered or viewed by strangers as a 'tweaker'. But I Am! I'm really screwed up and an addict and it's kind of ironic that society doesn't even notice. If I was a sloppy drunk or homeless junkie it would be obvious, but I'm just a working class 42 yr. women who also happens to be a crank freak! I look great everyone says--thin, pretty, all my teeth!
So I'm sure there are millions of normal acting/looking crank freaks just like me all over America, bored, overworked, chained to the fast lane of our lives and drug. We're Everywhere....This is epidemic, and society will hear us roar, perhaps too late. For my part, I need a new drug...or not...
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Home
Bio
Art Portfolio
Leaves scanned and modified in photoshop to camouflage a face [ART303-DIGITAL ART 1]
A leaf scanned and modified in photoshop to appear "digitized" [ART303-DIGITAL ART 1]
Leaves scanned and modified in photoshop to look like a moth [ART303-DIGITAL ART 1]
A hand-drawn 8-bit metroid [ART300-DRAWING]
Close
Download
Close
Download
Close
Download
Close
Code Portfolio Site
© James White 2016


Add and manage your AWESOME custom commands !
DisabledLet your members gain XP and levels by participating to the chat !
DisabledEnables the !help command.
Get the rank of a player at any time.

Add another bot Admin that can access this server dashboard.


Application for hobby farmers to trade or share their excess supplies to charities or other hobby farmers. Built with Ruby On Rails, 3rd Party APIs, PostgreSQL and React(partial).
Application for tourists planning a trip to New South Wales. This was a group project. Built with Ruby On Rails, 3rd Party APIs, PostgreSQL and Bootstrap, AJAX, JavaScript,CSS, HTML.


--- layout: default title: Who We Are tagline: Supporting tagline description: "The Word Lions team has a deep technical and communications background." --- {% include JB/setup %}
Joel started out as a telecommunications tech and IT administrator. He has been writing and structuring content for over ten years now, largely for technology and B2B offerings. Joel savors his new role teaching other writers the Word Lions Way. If you criticize yippie small dogs, he will flash a patient, indulgent smile and later introduce you to Torito, the chihuahua that will change your mind.
Karl joined Word Lions in 2011 after almost fifteen years in sales and management roles for telecommunications, IT, and software development. Karl has a talent for accessible, value-driven content. He also speaks Saleperson-ese, which helps us connect marketing with sales needs.
Over the years, Erik's code has sold guitars, balanced server loads, and served up any number of web services. Along with his understanding of the underpinnings of applications, Word Lions put his affinity for research to work. We could all stand to learn a little bit about proper attire from Erik.
Brooke is a writer and editor living in Los Angeles. A New England transplant, she earned a master's in writing from the University of Southern California and spent 12 years in advertising before foraging for freelance opportunities full time. She loves being a part of the Word Lions team and still thinks the Internet runs on magic.
Karl has been tweaking technology since the days of VisiCalc on the Apple ][+. He enjoys taking business puzzles and using technology to solve them, making people happy in the process. He's also brought his love of writing together with technology, writing about everything from SQL Server business intelligence to integrating social network services and new developments in electroacoustic music.
Robin Coleman brings 18 years of experience to graphic design, e-learning, and production. Her design chops are honed to respond to business, sales, and marketing needs. If she does not answer the phone, it is probably because she is out camping in a remote Pacific Northwest spot.
Hannah Barrett is a multidisciplinary designer who strives to create visual solutions. Her experience spans digital, print, branding, and more. When not doodling and messing about on her computer, you can find her out on the hiking trails or enjoying some brews.
We'd love to start a discussion about how we can help with your content marketing or training needs.


Services you can access
Based on the information you've given, you can access these services:
Apply to a school in your area Register with a local GP Apply for Universal Credit
You can also get information and advice from these external organisations:


A Twitter Bootstrap and Backbone.Marionette Starter Kit
Navbar Integration Since 0.0.1
Adding data-event attributes to your Navbar nav links enables events to trigger when the link is clicked.


Using the tools in the toolset one can set up services that handle TUI login on virtual terminals, and that provide virtual terminals entirely within application mode code, supplementing or even replacing the virtual terminals provided by a Linux or BSD operating system kernel.
To log on over virtual terminals, kernel or user-space,
one sets up ttylogin
services.
To use kernel virtual terminals one arranges for such services to be enabled and (demand-)started.
Terminals need various resources, some of which are supplied with the toolset.
Using the tools in the toolset one can set up services that handle TUI login on real terminals.
To log on over real terminals
one sets up ttylogin
services.


Neuroplasticity refers to the way that are brains are constantly changing, optimising themselves for the tasks they do the most. The neural pathways (collections of neurons that fire together) that are used often grow thicker, stronger and closer together, while neglected pathways are eventually 'pruned' away. This means that any new task, habit or thought can be difficult in the beginning, but with consistent practise those neural pathways will grow to be very strong and the action can be done with minimal effort. Because our brains aren't fixed, neither are our abilities - we are all able to change and improve, which is a very empowering thought.
Personally, the principles of neuroplasticity are most powerful to me in terms of my thoughts. If I'm regularly stressed or anxious, then my brain is going to get really good at producing stress hormones and keeping my body in quite a tense state. However, if I consistently practise being calm, both through meditation and by just noticing my thoughts throughout the day and choosing not to get caught up in them, I can make the calm, happy neural pathways stronger, and that will be my default state.
In order to improve your neuroplasticity...
A growth mindset is one that is aware of neuroplasticity - the mind's ability to grow and change - and therefore we approach new learning or any difficultly from the perspective that while we can't do 'x' yet, we can learn to. A fixed mindset would believe that our abilities are predetermined, and if we can't do something, we simply never will be able to, so we might as well give up. Meanwhile, the 'not yet' attitude of the growth mindset encourages us to ask questions and problem solve. Whenever we adopt a growth mindset, we strengthen the neural pathways of whatever we are learning, as well as this growth mindset pathway so that we will be more likely to take an open, curious attitude into the next problem we face.
My school had a pretty big focus on the growth mindset in terms of our learning, and so the idea of approaching any learning problems with 'the power of yet' isn't new to me, though it is good to be reminded of. Personally it's more things like the fact that I have OCD, which I pretty much see as a fixed identity statement about myself. Taking more of a growth mindset into that area of my life would allow me to feel more in control and like I can learn better ways to manage anxiety. (In the meantime though, at least my room is spotless!)
This TedTalk by Carol Dweck about a growth mindset in schools and the effect it has on student achievement is really interesting.


L'ultima Cena
Build Your Pizza!
Orders
Ingredients
Sizes
Great!
Your order was accepted successfully
Build your own pizza!
Name:
DNI:
Address:
Phone #:
Choose a size
Choose your ingredients
{{name}} - ${{price}}
{{name}} - ${{price}}
Order


Name: {{student.name}}
Grade: {{student.grade}}
School: {{student.school}}
Teacher: {{student.teacher}}


Menu Itrm
Menu Itrm
Menu Itrm
Menu Itrm
Menu Itrm
Menu Itrm
Menu Itrm
Title
Gallery
Products
Product Name
Bay
Product Name
Bay
Product Name
Bay
Product Name
Bay
Product Name
Bay
Product Name
Bay


--- layout: default layout_keyword: knowledge_base_page title: Export group member lists as .csv or .xls file tags: group_admin_pages left_col_section_nav: [admin_user_nav] user_help_videos: [admin_user_videos] ---
Easily export your member information in customizable lists as either .csv (comma-separated values) or .xls (excel) files.
To export member information, go to the top level group. Click More Tools > Group Settings in your Group Toolbox.
Using the search tool, you can narrow your results down by role.
Select the roles that you would like to display, then click Search. The new list will only display those roles that you selected.
Scroll to the bottom of the page and select either the .csv or .xls icon to start the export. Save your file to your desired location when prompted.


Health care is evolving rapidly. Changing reimbursements. More stringent patient requirements. New care delivery models. 3M understands your challenges and strives to make your job easier with reliable, quality products and solutions. We help you see more patients at lower costs, while improving overall health. That's health care progress made possible.
Health care is evolving rapidly. Changing reimbursements. More stringent patient requirements. New care delivery models. We understand your challenges and strive to make your job easier with reliable, quality products and solutions. Medical products that help prevent infection and promote healing. Oral care solutions that simplify procedures and improve outcomes. Automated intelligence solutions that get the right people the right information right when they need it. 3M products enable you to see more patients at lower costs, while improving overall health. That's health care progress made possible.
At 3M, we are experts in helping you focus on what’s most important: the patient. From stethoscopes and surgical masks to dental supplies and medical equipment, we aim to make your job easier and your outcomes better. Our wound care solutions help you provide the hands-on care your patients expect, while our medical equipment and food safety technologies help deliver the results you require.
Discover the 3M products making better health possible


// make sure that only the real part of the value
// is used, if `complex` is returned
values = sp.real(values)
// calculate loadings
// if values are smaller than 0, set them to zero
loadings = sp.dot(vectors, sp.diag(sp.sqrt(np.maximum(values, 0))))
// sort the values and vectors in ascending order
values = values[::-1][:n_factors]
vectors = vectors[:, ::-1][:, :n_factors]
// calculate loadings
// if values are smaller than 0, set them to zero


EnvironmentHelper
public class EnvironmentHelper
Helper class to detect the current environment and retrieve it from iOS app settings
Requires
1) Services.plist added to your project
2) This property list must contain the following String properties as in Environment
enum declaration:
- production
- staging
- develop 3) Settings.bundle registered for the application
-
Default environment. Can be modified externally
Declaration
Swift
public static var defaultEnvironment: EnvironmentHelper.Environment
-
Possible environments
See moreDeclaration
Swift
public enum Environment : String
-
Call this method to retrieve environment from user preferences
Declaration
Swift
public static func preferredEnvironment(or defaultEnvironment: Environment = defaultEnvironment) -> Environment
Parameters
defaultEnvironment
which environment to return if no preferred environment has been found. See also
EnvironmentHelper.defaultEnvironment
static propertyReturn Value
user preferred environment or default either set by user explicitly or implcitly stored in
EnvironmentHelper.defaultEnvironment
property -
Call this method to get url string associated with your environment
// retrieve your custom url from user preferences if any let customUrl = EnvironmentHelper.environmentUrlString(EnvironmentHelper.preferredEnvironment())
Declaration
Swift
public static func environmentUrlString(_ environment: Environment) -> String?
Parameters
environment
desired environment
Return Value
either string if Services.plist contains specified environment or nil


Hello {{to_name}},
First step is done! Your Bucket list is ready, Now it is up to you to take on new adventures.
{{message}}
Best wishes,
From MyBucketList


In ubuntu system, we can open the terminal to do some command operations, and then manage the files through commands. Following, we will introduce basic linux commands so that we can start to operate this system.
1. ls (list)
Use this command to know what files are in the directory you are in. You can see all the hidden files by using the command “ls -a”. Also, you can only show all text files by using the command “ls *.txt”.
2. cd (change directory)
Use the this command to go to a directory. For example, if you are in the home folder, and you want to go to the documents folder, then you can type in “cd Documents”. Remember, this command is case sensitive, and you have to type in the name of the folder exactly as it is. To go back from a folder to the folder before that, you can type “cd ..”. The two dots represent back.
3. pwd (print work directory)
To know which directory you are in, you can use the this command. It gives us the absolute path, which means the path that starts from the root. The root is the base of the Linux file system. It is denoted by a forward slash(/). The user directory is usually something like “/home/username/”.
4. mkdir (make directory)
Use this command when you need to create a folder or a directory. For example, if you want to make a directory called “Test”, then you can type “mkdir Test”. If you want to create a directory named “Just A Test”, then you can type “mkdir Just\ A\ Test”.
5. cp (copy)
Use this command to copy files through the command line. It takes two arguments: The first is the location of the file to be copied, the second is where to copy, such as “cp [source file path] [destination path]”.
6. mv (move files or rename files)
Use this command to move files through the command line. We can also use the mv command to rename a file. For example, if we want to rename the file “old.txt” to “new.txt”, we can use “mv old.txt new.txt”. It also takes the two arguments, just like the cp command.
7. rm (remove files)
Use this command to delete files and directories. Use “rm -r [directory name]” to delete just the directory. It deletes both the folder and the files it contains when using only the rm command.
8. touch
Use this command to create a file. It can be anything, from an empty txt file to an empty zip file. For example, “touch new.txt”.


| # | Command | Description |
|---|---|---|
| 1 | . | Run a command script in the current shell |
| 2 | !! | Run the last command again |
| 3 | ### | Comment / Remark |
| # | Command | Description |
|---|---|---|
| 1 | alias | Create an alias |
| 2 | apropos | Search Help manual pages (man -k) |
| 3 | apt-get | Search for and install software packages (Debian/Ubuntu) |
| 4 | aptitude | Search for and install software packages (Debian/Ubuntu) |
| 5 | aspell | Spell Checker |
| 6 | awk | Find and Replace text, database sort/validate/index |
| # | Command | Description |
|---|---|---|
| 1 | basename | Strip directory and suffix from filenames |
| 2 | bash | GNU Bourne-Again SHell |
| 3 | bc | Arbitrary precision calculator language |
| 4 | bg | Send to background |
| 5 | break | Exit from a loop |
| 6 | builtin | Run a shell builtin |
| 7 | bzip2 | Compress or decompress named file(s) |
| # | Command | Description |
|---|---|---|
| 1 | cal | Display a calendar |
| 2 | bash | GNU Bourne-Again SHell |
| 3 | case | Conditionally perform a command |
| 4 | cat | Concatenate and print (display) the content of files |
| 5 | cd | Change Directory |
| 6 | cfdisk | Partition table manipulator for Linux |
| 7 | chgrp | Change group ownership |
| 8 | chmod | Change access permissions |
| 9 | chown | Change file owner and group |
| 10 | chroot | Run a command with a different root directory |
| 11 | chkconfig | System services (runlevel) |
| 12 | cksum | Print CRC checksum and byte counts |
| 13 | clear | Clear terminal screen |
| 14 | cmp | Compare two files |
| 15 | comm | Compare two sorted files line by line |
| 16 | command | Run a command – ignoring shell functions |
| 17 | continue | Resume the next iteration of a loop |
| 18 | cp | Copy one or more files to another location |
| 19 | cron | Daemon to execute scheduled commands |
| 20 | crontab | Schedule a command to run at a later time |
| 21 | csplit | Split a file into context-determined pieces |
| 22 | curl | Transfer data from or to a server |
| 23 | cut | Divide a file into several parts |
| # | Command | Description |
|---|---|---|
| 1 | date | Display or change the date & time |
| 2 | dc | Desk Calculator |
| 3 | dd | Convert and copy a file, write disk headers, boot records |
| 4 | ddrescue | Data recovery tool |
| 5 | declare | Declare variables and give them attributes |
| 6 | df | Display free disk space |
| 7 | diff | Display the differences between two files |
| 8 | diff3 | Show differences among three files |
| 9 | dig | DNS lookup |
| 10 | dir | Briefly list directory contents |
| 11 | dircolors | Colour setup for `ls’ |
| 12 | dirname | Convert a full pathname to just a path |
| 13 | dirs | Display list of remembered directories |
| 14 | dmesg | Print kernel & driver messages |
| 15 | du | no data |
| # | Command | Description |
|---|---|---|
| 1 | echo | Display message on screen |
| 2 | egrep | Search file(s) for lines that match an extended expression |
| 3 | eject | Eject removable media |
| 4 | enable | Enable and disable builtin shell commands |
| 5 | env | Environment variables |
| 6 | ethtool | Ethernet card settings |
| 7 | eval | Evaluate several commands/arguments |
| 8 | exec | Execute a command |
| 9 | exit | Exit the shell |
| 10 | expect | Automate arbitrary applications accessed over a terminal |
| 11 | expand | Convert tabs to spaces |
| 12 | export | Set an environment variable |
| 13 | expr | Evaluate expressions |
| # | Command | Description |
|---|---|---|
| 1 | false | Do nothing, unsuccessfully |
| 2 | bash | GNU Bourne-Again SHell |
| 3 | fdformat | Low-level format a floppy disk |
| 4 | fdisk | Partition table manipulator for Linux |
| 5 | fg | Send job to foreground |
| 6 | fgrep | Search file(s) for lines that match a fixed string |
| 7 | file | Determine file type |
| 8 | find | Search for files that meet a desired criteria |
| 9 | fmt | Reformat paragraph text |
| 10 | fold | Wrap text to fit a specified width |
| 11 | for | Expand words, and execute commands |
| 12 | format | Format disks or tapes |
| 13 | free | Display memory usage |
| 14 | fsck | File system consistency check and repair |
| 15 | ftp | File Transfer Protocol |
| 16 | function | Define Function Macros |
| 17 | fuser | Identify/kill the process that is accessing a file |
| # | Command | Description |
|---|---|---|
| 1 | gawk | Find and Replace text within file(s) |
| 2 | getopts | GNU Bourne-Again SHell |
| 3 | getopts | Parse positional parameters |
| 4 | grep | Search file(s) for lines that match a given pattern |
| 5 | groupadd | Add a user security group |
| 6 | groupdel | Delete a group |
| 7 | groupmod | Modify a group |
| 8 | groups | Print group names a user is in |
| 9 | gzip | Compress or decompress named file(s) |
| # | Command | Description |
|---|---|---|
| 1 | hash | Remember the full pathname of a name argument |
| 2 | head | Output the first part of file(s) |
| 3 | help | Display help for a built-in command |
| 4 | history | Command History |
| 5 | hostname | Print or set system name |
| 6 | htop | Interactive process viewer |
| # | Command | Description |
|---|---|---|
| 1 | iconv | Convert the character set of a file |
| 2 | id | Print user and group id’s |
| 3 | if | Conditionally perform a command |
| 4 | ifconfig | Configure a network interface |
| 5 | ifdown | Stop a network interface |
| 6 | ifup | Start a network interface up |
| 7 | import | Capture an X server screen and save the image to file |
| 8 | install | Copy files and set attributes |
| 9 | ip | Routing, devices and tunnels |
| # | Command | Description |
|---|---|---|
| 1 | jobs | List active jobs |
| 2 | join | Join lines on a common field |
| # | Command | Description |
|---|---|---|
| 1 | kill | Kill a process by specifying its PID |
| 2 | killall | Kill processes by name |
| # | Command | Description |
|---|---|---|
| 1 | less | Display output one screen at a time |
| 2 | let | Perform arithmetic on shell variables |
| 3 | link | Create a link to a file |
| 4 | ln | Create a symbolic link to a file |
| 5 | local | Create variables |
| 6 | locate | Find files |
| 7 | logname | Print current login name |
| 8 | logout | Exit a login shell |
| 9 | look | Display lines beginning with a given string |
| 10 | lpc | Line printer control program |
| 11 | lpr | Off line print |
| 12 | lprint | Print a file |
| 13 | lprintd | Abort a print job |
| 8 | lprintq | List the print queue |
| 9 | lprm | Remove jobs from the print queue |
| 10 | ls | List information about file(s) |
| 11 | lsof | List open files |
| # | Command | Description |
|---|---|---|
| 1 | make | Recompile a group of programs |
| 2 | man | Help manual |
| 3 | mkdir | Create new folder(s) |
| 4 | mkfifo | Make FIFOs (named pipes) |
| 5 | mkisofs | Create an hybrid ISO9660/JOLIET/HFS filesystem |
| 6 | mknod | Make block or character special files |
| 7 | more | Display output one screen at a time |
| 8 | most | Browse or page through a text file |
| 9 | mount | Mount a file system |
| 10 | mtools | Manipulate MS-DOS files |
| 11 | mtr | Network diagnostics (traceroute/ping) |
| 12 | mv | Move or rename files or directories |
| 13 | mmv | Mass Move and rename (files) |
| # | Command | Description |
|---|---|---|
| 1 | nc | Netcat, read and write data across networks |
| 2 | netstat | Networking information |
| 3 | nice | Set the priority of a command or job |
| 4 | nl | Number lines and write files |
| 5 | nohub | Run a command immune to hangups |
| 6 | notify-send | Send desktop notifications |
| 7 | nslookup | Query Internet name servers interactively |
| # | Command | Description |
|---|---|---|
| 1 | open | Open a file in its default application |
| 2 | op | Operator access |
| # | Command | Description |
|---|---|---|
| 1 | passwd | Modify a user password |
| 2 | paste | Merge lines of files |
| 3 | pathchk | Check file name portability |
| 4 | ping | Test a network connection |
| 5 | pkill | Kill processes by a full or partial name |
| 6 | popd | Restore the previous value of the current directory |
| 7 | pr | Prepare files for printing |
| 8 | printcap | Printer capability database |
| 9 | printenv | Print environment variables |
| 10 | printf | Format and print data |
| 11 | ps | Process status |
| 12 | pushd | Save and then change the current director |
| 13 | pv | Monitor the progress of data through a pipe |
| 8 | pwd | Print Working Directory |
| # | Command | Description |
|---|---|---|
| 1 | quota | Display disk usage and limits |
| 2 | bash | GNU Bourne-Again SHell |
| 3 | quotacheck | Scan a file system for disk usag |
| # | Command | Description |
|---|---|---|
| 1 | ram | ram disk device |
| 2 | rar | Archive files with compression |
| 3 | rcp | Copy files between two machines |
| 4 | read | Read a line from standard input |
| 5 | readarray | Read from stdin into an array variable |
| 6 | readonly | Mark variables/functions as readonly |
| 7 | reboot | Reboot the system |
| 8 | rename | Rename files |
| 9 | renice | Alter priority of running processes |
| 10 | return | Exit a shell function |
| 11 | rev | Reverse lines of a file |
| 12 | rm | Remove files |
| 13 | rmdir | Remove folder(s) |
| 8 | rsync | Remote file copy (Synchronize file trees) |
| # | Command | Description |
|---|---|---|
| 1 | screen | Multiplex terminal, run remote shells via ssh |
| 2 | scp | Secure copy (remote file copy) |
| 3 | sdiff | Merge two files interactively |
| 4 | sed | Stream Editor |
| 5 | select | Accept keyboard input |
| 6 | seq | Print numeric sequences |
| 7 | set | Manipulate shell variables and functions |
| 8 | sftp | Secure File Transfer Program |
| 9 | shift | Shift positional parameters |
| 10 | shopt | Shell Options |
| 11 | shutdown | Shutdown or restart linux |
| 12 | sleep | Delay for a specified time |
| 13 | slocate | Find files |
| 8 | sort | Sort text files |
| 9 | source | Run commands from a file ‘.’ |
| 10 | split | Split a file into fixed-size pieces |
| 11 | ssh | Secure Shell client (remote login program) |
| 12 | stat | Display file or file system status |
| 13 | strace | Trace system calls and signals |
| 14 | su | Substitute user identity |
| 15 | sudo | Execute a command as another user |
| 16 | sum | Print a checksum for a file |
| 17 | suspend | Suspend execution of this shell |
| 18 | sync | Synchronize data on disk with memory |
| # | Command | Description |
|---|---|---|
| 1 | tail | Output the last part of file |
| 2 | tar | Store, list or extract files in an archive |
| 3 | tee | Redirect output to multiple files |
| 4 | test | Evaluate a conditional expression |
| 5 | time | Measure Program running time |
| 6 | timeout | Run a command with a time limit |
| 7 | times | User and system times |
| 8 | touch | Change file timestamps |
| 9 | top | List processes running on the system |
| 10 | tput | Set terminal-dependent capabilities, color, position |
| 11 | traceroute | Trace Route to Host |
| 12 | trap | Run a command when a signal is set(bourne) |
| 13 | tr | Translate, squeeze, and/or delete characters |
| 8 | true | Do nothing, successfully |
| 9 | tsort | Topological sort |
| 10 | tty | Print filename of terminal on stdin |
| # | Command | Description |
|---|---|---|
| 1 | ulimit | Limit user resources |
| 2 | umask | Users file creation mask |
| 3 | unmount | Unmount a device |
| 4 | unalias | Remove an alias |
| 5 | uname | Print system information |
| 6 | unexpand | Convert spaces to tabs |
| 7 | uniq | Uniquify files |
| 8 | units | Convert units from one scale to another |
| 9 | unrar | Extract files from a rar archive |
| 10 | unset | Remove variable or function names |
| 11 | unshar | Unpack shell archive scripts |
| 12 | until | Execute commands (until error) |
| 13 | uptime | Show uptime |
| 8 | useradd | Create new user account |
| 9 | userdel | Delete a user account |
| 10 | usermod | Modify user account |
| 11 | users | List users currently logged in |
| 12 | uuencode | Encode a binary file |
| 13 | uudecode | Decode a file created by uuencode |
| # | Command | Description |
|---|---|---|
| 1 | vdir | Verbosely list directory contents (`ls -l -b’) |
| 2 | vi | Text Editor |
| 3 | vmstat | Report virtual memory statistics |
| # | Command | Description |
|---|---|---|
| 1 | wait | Wait for a process to complete |
| 2 | watch | Execute/display a program periodically |
| 3 | wc | Print byte, word, and line counts |
| 4 | whereis | Search the user’s $path, man pages and source files for a program |
| 5 | which | Search the user’s $path for a program file |
| 6 | while | Execute commands |
| 7 | who | Print all usernames currently logged in |
| 8 | whoami | Print the current user id and name (`id -un’) |
| 9 | wget | Retrieve web pages or files via HTTP, HTTPS or FTP |
| 10 | write | Send a message to another user |
| # | Command | Description |
|---|---|---|
| 1 | xargs | Execute utility, passing constructed argument list(s) |
| 3 | xdg-open | Open a file or URL in the user’s preferred application |
| 4 | xz | Compress or decompress .xz and .lzma files |
| # | Command | Description |
|---|---|---|
| 1 | yes | Print a string until interrupted |
| # | Command | Description |
|---|---|---|
| 1 | zip | Package and compress (archive) files |


Players will take turns to roll the die.
You can only stop rolling if you click the 'hold' button.

This is a cue for player 2 to start playing
The game ends when one of the players gets to 100 points first


Set of metadata compliant with the LOM standard
This editor lets you modify the elements which are considered more relevant in order to clasify games created with this platform. The games exported as Learning Objects of type "SCORM2004, IMS CP and CP WEBCT 4" will have the metadata filled in this editor.
If you want to expand these data, the package must be opened with any editor of learning objects (such the Reload Editor), or open the file "manifest.xml" (included in the root folder of the Learning Object) with a LOM metadata editor .
For more information, check out the website http://ltsc.ieee.org/wg12/ .


Danny and Jonnie. My new buddies. Maybe they just don’t know it yet. Might not even be buddies themselves. They sound the same to me. Both statements refer to a similar, if not the same, state. An oxymoronic sounding: relaxed alertness, calm activity, or an unexpectant anticipation. Knowing yourself, and finding a comfortable balance between: a healthy admiration of your identity, strengths and talents; and a realization of: your own deficiencies, faults and weaknesses, can be your strongest experiential correlation tool.
Body scan is something I cheat can at, or at least I'm familiar with . I didn’t know it was a thing. I do it a bit un/sub/consciously when I want to chill out on a sun lounger or lie down in bed. I’ve a couple of injuries ( nothing heroic I’m afraid ) that I need to take into account. I find that identifying the physical sensations (?) makes it a a bit easier to compartmentalise them and to nullify their influence. Of course it’s a important thing to be aware of: the ‘cause and effect’ of an environment on a physical body, and no better way than to dissociate the mind(fullness) from it than by a methodical recognition of it’s parts. Bloody relaxing as well … in a Zen way.
I wonder if a subtle change in our language could help us here a little bit. In French, as in loads of other languages I guess, we ‘are’ not an age for example but rather we ‘have ‘ age. I imagine thinking therefore, that I ‘have’ : anger, sadness or inappropriately wild joy after finding the missing semi-colon; not that I ‘am’ any of these emotions. Bearing this in mind I can train myself to ‘not have’ them too. I remain the same. Whoo hoo ! . A quantum mechanic might disagree of course but then you can’t please all the people all the time.


When you want to add new record into the Students table you should click on "Add Student Record" button.
You should see the following window
In "Student Number" field enter desired integer value.
In "Student Name" field enter full student name.
In "Student Address" field enter student's home address.


Optional features
RER has lots of optional features you may want to enable/disable. Here is a
list of the toggles and what they do
- Enable encounters loot when set to OFF completely removes any loot from RER, creature
materials included
- Enable Geralt comments when set to ON, Geralt will play a voiceline whenever an encounter
is created. Trail's fresh for hunts and he'll slur upon being Ambushed
- Enable action camera scenes when you get ambushed a camera scene will play
showing you the creatures who are about to ambush you. Setting it to OFF will remove this camera scene
- Only known bestiary creatures when set to ON, RER won't spawn any creature that
isn't in your bestiary yet. Therby guaranteeing you a playthrough without any spoilers.
- Hide RER notifications when set to OFF will remove some unimportant notifications
that RER may create
- Disable camera scenes when set to OFF will disable all camera scenes created by RER
- Disable camera blending when set to OFF will remove the smooth transition when a camera
scene starts and ends. The transition between the scene camera and the default Geralt camera.
- No camera scene on horse is a compatibility option with Immersive Camera.
IC has a bug in its camera code that makes the game crash during blended transitions, but only
in horse and combat states.
- Delay RER loading start (Bootstrap Hooked compatibility) is a compatibility option for
the Bootstrap Hooked users. This version of bootstrap loads RER so early the bounty master is not
loaded properly and it causes a crash and him whispering in your ear every time you load your save.
The option simply delays RER loading by a few seconds.

- Use path finding for trails when set to ON, will enable path finding when drawing trails.
It means that trails will avoid some obstacles and will try to go in a realistic path.
- Markers toggles control if you want map marker in the different situations.
- Skip bounty seed selector window when set to ON will skip the seed selection window
and use the seed 0 instead
- Shorten bounty master conversation when set to ON will skip a good portion of the bounty master conversation
- Dynamic creatures size when set to ON allows RER to dynamically change the size of the spawned creatures based on their level. Higher level creatures are bigger and lower level ones are smaller.
- Noticeboard errands to start RER contracts when set to ON allows RER to dynamically inject errands (notices) to noticeboards. RER contracts can be started by picking the errands.


abstract val membershipParametersHash: SecureHash?
Hash of the network parameters that were in force when the transaction was notarised. Null means, that the transaction was created on older version of Corda (before 4), resolution will default to initial parameters.


{{>header}}
This system allows users to record content at any URL, and track their experiences with that content. User information such as a name and an email address are provide to the content so it can log interactions. The server sets up a single use xAPI proxy, and provides this proxy location to the content. Each launch of the content is associated with a one-time-use token, which activates the proxy endpoint and establishes a session for the content. Anyone may submit data to this endpoint given that they have access to the launch token and the session key. However, once the launch token has been exchanged for the launch information, only clients with the proper session token can request the user data or post to the xAPI endpoint. The link submitter can enter an optional RSA Public Key for the content. If provided, the API data will be encrypted before being returned to the user. The user therefore may not know the API endpoints.
All statements which are logged via the one-time-use proxy endpoint are automatically associated with a context activitiy to identify the content from which it came, as well as a context activity to identify the session of the content during which it was posted. In this way, a student can see the result for each launch of the content, and a content owner can see the results of each attempt on the course.
The static content file located in the /public folder implements the most basic possible interaction. It uses a library to manage to token exchange round-trip, and specifies that the library should consider the attempt complete when the page unloads. Closing the attempt is the applications responsibility.
See all the registered courses in the database. Each course can be hosted anywhere on the net - or even a local app. So long as it can read the token from the URL query string and make an HTTP post, it can initiate the session and retreive the user info.
You must create an account on this site to enroll content, to launch content, or to view various data base records.
Add new content to the database. This content should use the XAPI launch mechanism to initialize learner tracking.


Teens in Space - Character Sheets
Generate
a random character. You can save these to localstorage. Simply refresh the page to generate a new one!
Administrate
saved characters in localstorage.
Whos-Yer-Con
Rence Hills
Athen Petal
Jomy Storrels
Mely Garm
Ristol Sones
Joanna Moarte
Tholie Emall
Tephy Rezal
Johnnio Krillee
Atris Arnes
Qed Kulari
Katta Kaprica


Document Viewer
AngularJS application with RESTful API
Built an AngularJS front-end application that connects to a json API to retrieve various documents used by the finance office. Note: The testing backend was taken offline so the screenshot doesn’t show the finished product.
- Client: Columbia University Finance Office
- Date: Winter 2016-2017
- Service: Front-end Application
Note: Data endpoints were disabled for the screenshot to protect confidential data


%+usbleach/header%>
You can't browse <%= device %>'s files as this partition is not available right now (device umounted?).


Sprint 3 Technical Blog
All About Javascript
And a bit of HTML/CSS
HTML and CSS
A website can be written in many different languages. But the core of any website will be HTML and CSS. Html is a markup language, which means it is used to “mark up” what information is going to be presented on the page, and what the basic structure will be. By adding CSS we can style and arrange the information to make it more appealing and user friendly.
Control Flow and Loops
Javascript is a programming language that executes from the top down. The control flow is essentially just the order of execution, or which code is executed first, second, third, etc… It is important to understand how control flow is working in your code, otherwise the code will not run as intended.
You can think of this as being similar to baking a cake where each step must be followed. You must first preheat the oven, then mix the dry ingredients, and maybe then you may need to prepare the wet ingredients in their own bowl, then you would cook the mixture, and apply frosting or icing to the top. If you were to do these steps out of order it would be very difficult to come to a final outcome that is as yummy as if you were to follow the directions step by step. Imagine putting the dry ingredients, wet ingredients and icing into a bowl. Placing it in the oven, and then preheating the oven. Taking the mixture and waiting for the oven timer to go off. It would not work.
Looping is when there is a particular piece of code that needs to be repeated until a certain condition is met. This is useful when you have a piece of code that needs to be repeated multiple times, but it would be wasteful to write out the code again and again and again.
Looping can be compared to swimming in a swimming pool. When you are swimming you must complete a single action over and over, this is called a stroke. When you repeat the stroke over and over you will find that your body moves through the water. But because the swimming pool ends, you must also have a strategy for stopping your body from moving. So after completing the strokes, you might notice the flags above the lane that indicate the lane is coming to an end. You can then stop, or (break) the loop and slow your body to a stop.
The DOM
The DOM, or Document Object Model, is a programming interface that allows javascript to reach into the HTMl and CSS to manipulate its structure, style and content. It does this by breaking down the content of the document into a tree structure, where each element of the document is represented as a node. The visual representation of the DOM is similar to a family tree, where there is a parent and child for each part of the document. By structuring the document this way, the DOM is able to be easily traversed in order to pull out and reference content or styles when needed.
Arrays vs Objects
Arrays and Objects are very similar, they are both a way of containing data.
Arrays are stored within a variable, and are used to store a list of values. These values can be Numbers, Strings and or Booleans and can be used by a function to call these values when needed. They are used to store large amounts of information for later use.
An Array is like a lunchbox, it can contain many different foods. It can contain, oranges, steak, pasta, sandwiches, muesli bars… anything you can imagine, but it is after all a lunch box, so it’s use is to store food.
Objects are a container that enclose data and behaviour together. They have properties applied to them, but also methods, or functions, which describe what the object can do. So, much like an Array they can store multiples pieces of information, but the benefit of an object is the ability to add functionality to these objects by specifying what the objects can do.
An object is like an object in real life. Objects in real life have physical properties, like height, width, colour, specific markings or indentations, maybe even buttons or knobs… But the key aspect of an object is that is DOES something. For example, a wind up Hot Wheels car has colours, text, physical characteristics. But it also has the functionality of winding up and releasing so that the car can move.
Functions
Functions are the part of JavaScript that gives the code functionality (if that wasn’t clear by the name). Functions are executed when they are called by the script, this can occur in different ways. You can call a function on and event, or automatically.
Functions are like tricks that you might teach your pet. You might train them to sit, stay, play dead, roll over, speak or shake hands. In order to do this you have to describe to the animal what it is you want them to do, this is normally done by showing them or guiding them to the final outcome. And then, when you want to impress your friends by showing off your pets new trick, you can call the “function” by speaking the command word “sit” or “stay” etc… and the function of the command word will be executed.
Back To Top


|
Broadband
High speed internet chat. Rogers, Shaw, Sympatico
and more.
Chit
Chat
Canadian Chat topics surrounding everything.
Computers
Software, hardware, security and more.
Politics
Canadian political forum discussion trade disputes,
world events and more.