Privacy Policy 隱私權政策
Updated: 2021-05-04
For helping the user study, this App will store necessary information on
the user's device and the user is conscious that it is stored. So, what
kind of private data will be taken?
為了幫助使用者學習，所以，本APP會在使用者有意識的情況下儲存必要的資料。不過，哪些資料會被存取呢？
There are three kinds of data: 有分為三類的資料：
-
The profile you made for a link to a multimedia
(您為多媒體連結所製作的配置檔)
from which you can output as a mdpyc file. (而它可輸出為 mdpyc 檔)
-
Before exporting it as a file, it will only be stored in this App
on your device and will not be shared.
在輸出為檔案前，它都只存留在您裝置上的此App上，不會外流。
-
After exporting as a file (on the cloud or on a device), if you
distribute it, you can share your work with others; but,
conversely, if you write private information in it, it will also
be outflowed. Therefore, do not write private information on it.
在輸出為檔案後(雲端上或裝置上)，若散佈它，就可與他人分享你的工作；但是，反過來說，若您在裏頭輸入私人資訊，也就會外流。因此，別在其上輸入私人資料。
-
Resources needed for making study more efficient:
為方便學習而要求的資源：
-
Settings related to this APP , such as the link of "Daily
Sample"
本APP相關設定，如每日一例的連結
-
(iOS) Camera + Microphone : Because the new iOS system can
retrieve a file from the user's camera directly, it will use your
camera only if you want to load a file from your camera.
(iOS)照相機+麥克風：
因為新版的iOS系統可以直接由照相機擷取影像變為檔案，當你要抓取檔案時，若選取由照相機取得，此功能才會被啟用。
-
Microphone : Because when learning a language, it would be
better if you could record your own voice at the same time. So,
when the user wants to do this, the microphone is used.
麥克風：
因為學習語言時，若能同時錄製自己的聲音來比對，那會更好。所以，當使用者想要如此做時，就會使用到麥克風。
-
Cloud APIs (雲端服務APIs)
This App only helps you connect with these APIs, and the data required
for authorization is not processed by this App (in fact, this App
cannot get it).
本App只幫您與這些API牽線，授權所需的資料本App不處理(事實上也拿不到)
-
Your profile (name and image) 你的名字與像
They are used to notify you that you have logged in.
僅用來提示您已經登入 Google 了。
-
Google Drive API: (Google 雲端硬碟)
-
lay a settings file for this App so that you can have the same
settings on any device.
安放設定檔，這樣，此App就可以在您不同裝置上都有相同配置。
-
Output mdpyc file (輸出mdpyc檔)
It has three types: normal, zip and spreadsheet. All of them
are output in YOUR OWN Google Drive only. Others and I cannot
get them.
它有三種型態：正常、Zip與Google工作表。這些檔案只會輸出到您的Google雲端硬碟上。我或別人都看不到，除非你將他們分享。
-
NOTE: Google Sheets API is used when you output it as a
spreadsheet file.
-
None of these will be sent to any other server, they just are used
on these API services.
這些都不會發送到任何其他伺服器，它們僅用於這些 API 服務。
Finally, this app is written with a clean conscience; therefore, I avoid
to touch the user’s private information. It also carefully considers the
protection of users' private data. But, just like some thieves are very
capable, I cannot guarantee that this App can 100% prevent this kind of
threaten. So, if you find any improvements to this App, please feel free
to give us advice. Thank you.
最後，本人本著清潔的良心寫此App，能不碰到使用者私人的資料就避免碰到，
也慎重地將保護使用者的私人資料考慮進來。但是，就像有的小偷就是很有辦法，
所以，若有發現本App可以改進的地方，歡迎賜教。謝謝。


language package.path.to.Parser { ... }
Where Parser
is the name of the resulting java file and package.path.to
is the package in which the class resides. The package-part is optional for the parser, but necessary for the parser project.
A statement has the following layout:
<modifiers> name = <items>.
Where:
A brief explanation of a parser is a program which associates labels to parts of a text which corresponds to given patterns.
Comments are preceded by '#'
and go till the end of the line.
a b c | d e | fWill match as:
a b ( c | d ) ( e | f )You will need to brace explicitly to indicate your intention. eg:
( a b c ) | ( d e ) | ( f )
Special characters are denoted by a preceding backslash, eg:
\r \n \t - respectively carriage return, line feed, tab
A character class can include ranges, eg: [a-zA-Z0-9]
.
Special class [\all]
matches everything.
[\all]
can be expanded with an exclusion set, for example:
[\all~\r\n] - match all characters EXCEPT carriage returns and line feeds.
( a b c )
Thus { [a] }
will match
(Assuming whitespace parsing is on):
In addition, the following postfixes can appear behind (almost) every statement:
Whitespace is defined by statement with label 'WS'. If you do not include this, the following default definition will be used:
WS = [ \r\t\n]+.
These modifiers can appear between statements. After a noWS, all statements are assumed to be parsed without whitespace in between. After a skipWS, whitespace is assumed to be between every item.
These modifiers can also appear within a statement. The working is the same; from the point noWS appears, no more whitespace is parsed until skipWS is encountered. These settings are for within the statement only; they are reset when the statement has been handled.
Statement prefixes are used to tell the parser how to handle a given parse result in the output. They are optional and not necessary for a succesful parse.
The following are used as prefixes for statements:
token
reduces this structure to a flat string value. The
contents are retained, but the child-labels are discarded.
Please avoid java keywords as names for statements.


Blackwhite. Wow.
When I read the above quote on learning the command line I immediately thought of George Orwell and his brilliant description of blackwhite from "1984".
To be fair, this statement was likely meant to be motivating or at least a fear reducing, "Now this won't hurt a bit." Still, come to think of it, isn't that what doctors say to patients before doing something that will hurt alot?
It was once my job to measure this. In the late 80's and early 90's I worked at Apple. One of my early jobs was as a product manager for UNIX and for the Macintosh Programmer's Workshop, a development system which was mostly a command line affair but which did UNIX one (or more) better. We studied the time it took to do simple and complax tasks.
Testing the new way.
GUI based IDEs were just coming out: Lightspeed C and Pascal (then Metrowerks, then NextStep, then XCode.) (For a modern equivalent see a video review of RubyMine) You probably don't know those those IDE's but we deeply studied file navigation as mentioned in the quote. A user in a GUI clicks to open folders, clicks or drags to select multiple files, then drags, hovers over a folder to have it automatically open and then drops the file(s). A command line user types a list of commands.
ls;
cd path
ls;
cp regex path
stop...what was that destination path?
cp regex path
...
The GUI was 10 times faster than the command line. In the hands of a novice user it was the difference between getting something done and getting nothing done. Surprisingly to some, though, even with command line experts the more complex the task, the more the GUI won. The command line guys were pretty darn fast too. Our laptop keyboards today are built to be thin, not fast.
And we never had to restore a GUI user's system from backup while command line file manipulation errors had a tendency to go catastrophic. Imaging combining the most destructive task -- file deletion, with the most cryptic, error prone command structure -- regular expressions. It was like the joke where the civil engineer tells the doctor and lawyer that in fact God must be civil engineer because who else would route a waste disposal system through a recreational area? The command line guys made fun of the GUI user's desktop and Trash can but they couldn't undo an rm.
Resource building
Here's a funny story. Our little resource editor, ResEdit, got no love. Resources are little bits of code, sometimes visual or with color attributes or a design like an icon. RedEdit was actually a collection of editors, each specialized to it's task. It was a GUI tool which was loved by external developers but reviled by the text and command line crowd internally. Only wimps used it. It wasn't professional.
There were plans to cut it. Then an interesting thing happened.
We decided to do an informal survey. I think it was to cover our backsides before killing ResEdit. We used a little known fact that for debugging purposes, ResEdit embedded a version string in the binary of the resources it made. You could therefore tell by looking at the file data for a resource if ResEdit made it.
Surprise! Most resources, even those created by those in the anti-ResEdit camp were created using ResEdit. When the doors were closed and no one was looking, real programmers went back and used the GUI tool.
The real strength of the GUI was not speed but the fact that you didn't have to memorize a bazillion arcane bits of info just to get anything done. It allows you to see what you are doing. Even a lowly dialog box reminds you of what the options are and what their legal values are without having to read some of the most poorly written prose in the English language: "man" pages.
A GUI, even if it's just a dialog box, allows you to do things you're not sure how to do without having to spend hours in research. The command line just sits there and dares you to perfectly type the exact arcane commands. Discovery is painful.
When Keyboard Centric Works
We did find cases where the keyboard was faster, but really it wasn't the command line per-se, it was a keyboard centric approach that was fastest.
Editing text where fonts and styles don't matter, where the program auto-formats and colorizes, e.g. the user doesn’t put in bold, italic colors and font sizes, or layout, and where the content is structured programming code. Now you have a different game. It's a limited domain and can be optimized.
Moving around in a small environment of files such as a project can be faster using only the keyboard providing you memorize the entire structure or, like Rails, it's a limited domain and the structure doesn't change, i.e there's eventually no need of discovery.
Sublime Text is a wonderful example. They have spent a lot of time thinking about how fast you can move around in this limited domain and never take your hand off the keyboard. As you auto-complete file names you only need to type the letters that make a filename unique, something a human mind is astoundingly good at. "p0u2" uniquely identifies "phase-0-unit-2." Sublime is looking throughout your project in the background. As you do are narrowing down the filename, files are prepp'ed in the background so that when you have a unique match it's already open.
Hybrid Designs
Often at Apple we found there was a simple hybrid solution gave the best of both. I think it was shift-return that would open a dialog box that would then let you tab through the arcane options that no one could ever remember. I'd love this for git when I need to fork, pull, or reset the head. A dialog can remind the user of the available options when typing an unfamiliar complex command can be a nightmare. The Macintosh Programmers' Workshop had this and it was one of it's best features. I often wonder if this could be adopted for Linux, ctrl-return to pop a up command-line dialog.
It's Old Tech
The truth is that command line interpreters are 60's tech; they were invented before technology allowed for anything else, when there was no wysiwyg or drag and drop, no notion of encapsulating a command into a button, or a file into an icon. Once you have been forced to learn such a thing it becomes a badge of honor. A reason why you are better than the other guy.
This happens a lot in the tech world. There is a tremendous reticence to give up a skill that elevates you in status above others in some way, even if there is a better, stronger, faster way. Call it the narcissism of the command line. If there's an easier way that requires little training and you've spent years learning the hard way, that's just not good news. So some hold stubbornly to the old and "get to navigate with commands". Yeah, and we all want to go back to DOS. I can hear the stampede. Luckily there are innovations being made in tools like Sublime Text but as long as I have to switch environments just to debug and type in debugger statements I'll stick with RubyMine, WebStorm and learn Vintage. Modern easy, fast, and beautiful interfaces are all around you. Let's not call the page black and the type white...unless of course you've customized your editor's theme that way.


{% extends "base.html" %} {% block title %}Engine{% endblock %} {% block content %}
The Ducttape Engine is a C++ open-source game engine using Ogre3D for graphics, SFML for network and audio and the Bullet Physics engine.
The Ducttape Engine and its components such as the editor as well as examples and tests are available under the LGPL3 license unless noted otherwise.
This is the list of goals the Ducttape Engine is made for, sorted by descending priority.
You want to participate? No problem! Just fork the github repository, take an issue from the github issue tracker and join the fun! Just let us know about what you're doing.
{% endblock %}


In review: Design, Architecture and Craft!
Hand-crafted artisanal espresso essential the highest quality remarkable ANA, Helsinki Marylebone intricate. Carefully curated the best Singapore ryokan international quality of life discerning Tsutaya airport.
February 9th, 2018


So, you're trying to contact me...
Well that's great acually. Send an email below:
---
layout: default
---
So, you're trying to contact me...
Well that's great acually. Send an email below:
Hello


HTML (Hypertext Markup Language) is not a programming language; it is a markup language used to tell your browser how to structure the web pages you visit. It can be as complicated or as simple as the web developer wishes it to be. HTML consists of a series of elements, which you use to enclose, wrap, or mark up different parts of the content to make it appear or act a certain way. The enclosing tags can make a bit of content into a hyperlink to link to another page on the web, italicize words, and so on. For example, take the following line of content:
My cat is very grumpy
If we wanted the line to stand by itself, we could specify that it is a paragraph by enclosing it in a paragraph
 element:

My cat is very grumpy

Note: Elements in HTML are case-insensitive, i.e. they can be written in uppercase or lowercase. For example, a <title> element could be written as <title>, <TITLE>, <Title>, <TiTlE>, etc., and it will work fine. Best practice, however, is to write all elements lowercase for consistency, readability, and other reasons.
Anatomy of an HTML element
Let's explore our paragraph element a bit further:
The main parts of our element are:
The opening tag: This consists of the name of the element (in this case, p), wrapped in opening and closing angle brackets. This states where the element begins or starts to take effect — in this case where the start of the paragraph is.
The closing tag: This is the same as the opening tag, except that it includes a forward slash before the element name. This states where the element ends — in this case where the end of the paragraph is. Failing to include a closing tag is a common beginner error and can lead to strange results.
The content: This is the content of the element, which in this case is just text.
The element: The opening tag plus the closing tag plus the content equals the element.
Nesting elements
You can put elements inside other elements too — this is called nesting. If we wanted to state that our cat is very grumpy, we could wrap the word "very" in a  element, which means that the word is to be strongly emphasized:

My cat is very grumpy.

You do however need to make sure that your elements are properly nested: in the example above, we opened the p element first, then the strong element, therefore we have to close the strong element first, then the p. The following is incorrect:

My cat is very grumpy.

The elements have to open and close correctly, so they are clearly inside or outside one another. If they overlap like above, then your web browser will try to make a best guess at what you were trying to say, and you may well get unexpected results. So don't do it!
Block versus inline elements
There are two important categories of elements in HTML which you should know about. They are block-level elements and inline elements.
Block-level elements form a visible block on a page — they will appear on a new line from whatever content went before it, and any content that goes after it will also appear on a new line. Block-level elements tend to be structural elements on the page that represent, for example, paragraphs, lists, navigation menus, footers, etc. A block-level element wouldn't be nested inside an inline element, but it might be nested inside another block-level element.
Inline elements are those that are contained within block-level elements and surround only small parts of the document’s content, not entire paragraphs and groupings of content. An inline element will not cause a new line to appear in the document; they would normally appear inside a paragraph of text, for example an  element (hyperlink) or emphasis elements such as  or .

 is an inline element, so as you can see below, the first three elements sit on the same line as one another with no space in between. On the other hand,
 is a block-level element, so each element appears on a new line, with space above and below each (the spacing is due to default CSS styling that the browser applies to paragraphs).
firstsecondthird
fourth
fifth
sixth
Note: HTML5 redefined the element categories in HTML5. While these definitions are more accurate and less ambiguous than the ones that went before, they are a lot more complicated to understand than "block" and "inline", so we will stick with these throughout this topic.
Note: The terms "block" and "inline", as used in this topic, should not be confused with the types of CSS boxes with the same names. While they correlate by default, changing the CSS display type doesn't change the category of the element and doesn't affect which elements it can contain and which elements it can be contained in. One of the reasons why HTML5 dropped these terms was to prevent this rather common confusion.
Empty elements
Not all elements follow the above pattern of opening tag, content, closing tag. Some elements consist only of a single tag, which is usually used to insert/embed something in the document at the place it is included. For example, the  element embeds an image file onto a page in the position it is included in:
Note:Empty elements are also sometimes called void elements.
Attributes
Elements can also have attributes, which look like this:
Attributes contain extra information about the element which you don't want to appear in the actual content. In this case, the class attribute allows you to give the element an identifying name that can be later used to target the element with style information and other things.
An attribute should have:
A space between it and the element name (or the previous attribute, if the element already has one or more attributes.)
The attribute name, followed by an equals sign.
An attribute value, with opening and closing quote marks wrapped around it.
Boolean attributes
You'll sometimes see attributes written without values — this is perfectly allowed. These are called boolean attributes, and they can only have one value, which is generally the same as the attribute name. As an example, take the disabled attribute, which you can assign to form input elements if you want them to be disabled (greyed out) so the user can't enter any data in them.
<input type="text" disabled="disabled">
As shorthand, it is perfectly allowable to write this as follows (we've also included a non-disabled form input element for reference, to give you more of an idea what is going on):
<input type="text" disabled>
<input type="text">
Both will give you an output as follows:
Omitting quotes around attribute values
When you look around the World Wide Web, you'll come across all kind of strange markup styles, including attribute values without quotes. This is allowable in certain circumstances, but will break your markup in others. For example, if we revisit our link example from earlier, we could write a basic version with only the href attribute, like this:
However, as soon as we add the title attribute in this style, things will go wrong:
favourite website
At this point the browser will misinterpret your markup, thinking that the title attribute is actually three attributes — a title attribute with the value "The", and two boolean attributes, Mozilla and homepage. This is obviously not what was intended, and will cause errors or unexpected behavior in the code, as seen in the live example below. Try hovering over the link to see what the title text is!
Our advice is to always include the attribute quotes — it avoids such problems, and results in more readable code too.
Single or double quotes?
In this article you'll notice that the attributes are all wrapped in double quotes. You might however see single quotes in some people's HTML. This is purely a matter of style, and you can feel free to choose which one you prefer. Both the following lines are equivalent:
A link to my example.
A link to my example.
You should however make sure you don't mix them together. The following will go wrong!
A link to my example.
If you've used one type of quote in your HTML, you can include the other type of quote without causing any problems:
A link to my example.
However if you want to include a quote within the quotes where both the quotes are of the same type(single quote or double quote), you'll have to use HTML entities for the quotes.
Anatomy of a HTML Document
That wraps up the basics of individual HTML elements, but they aren't very useful on their own. Now we'll look at how individual elements are combined to form an entire HTML page:
<!DOCTYPE html>

<meta charset="utf-8">
<title>My test page</title>

This is my page

Here we have:
<!DOCTYPE html>: The doctype. In the mists of time, when HTML was young (about 1991/2), doctypes were meant to act as links to a set of rules that the HTML page had to follow to be considered good HTML, which could mean automatic error checking and other useful things. They used to look something like this:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
However, these days no one really cares about them, and they are really just a historical artifact that needs to be included for everything to work right. <!DOCTYPE html> is the shortest string of characters that counts as a valid doctype; that's all you really need to know.
: The element. This element wraps all the content on the entire page, and is sometimes known as the root element.
: The  element. This element acts as a container for all the stuff you want to include on the HTML page that isn't the content you are showing to your page's viewers. This includes things like keywords and a page description that you want to appear in search results, CSS to style our content, character set declarations, and more. You'll learn more about this in the next article in the series.
<meta charset="utf-8">: This element sets the character set your document should use to UTF-8, which includes most characters from the vast majority of human written languages. Essentially it can now handle any textual content you might put on it. There is no reason not to set this, and it can help avoid some problems later.
<title></title>: The <title> element. This sets the title of your page, which is the title that appears in the browser tab the page is loaded in, and is used to describe the page when you bookmark/favorite it.
: The  element. This contains all the content that you want to show to web users when they visit your page, whether that's text, images, videos, games, playable audio tracks, or whatever else.
Whitespace in HTML
In the above examples you may have noticed that a lot of whitespace is included in the code listings — this is not necessary at all; the two following code snippets are equivalent:

Dogs are silly.

Dogs are
silly.

No matter how much whitespace you use (which can include space characters, but also line breaks), the HTML parser reduces each one down to a single space when rendering the code. So why use so much whitespace? The answer is readability — it is so much easier to understand what is going on in your code if you have it nicely formatted, and not just bunched up together in a big mess. In our HTML we've got each nested element indented by two spaces more than the one it is sitting inside. It is up to you what style of formatting you use (how many spaces for each level of indentation, for example), but you should consider formatting it.
Entity references Including special characters in HTML
In HTML, the characters <, >,",' and & are special characters. They are parts of the HTML syntax itself, so how do you include one of these characters in your text, for example if you really want to use an ampersand or less than sign, and not have it interpreted as code as some browsers may do?
We have to use character references — special codes that represent characters, and can be used in these exact circumstances. Each character reference is started with an ampersand (&), and ended by a semicolon (;).
In the below example, you can see two paragraphs, which are talking about web technologies:

In HTML, you define a paragraph using the
 element.

In HTML, you define a paragraph using the
 element.

In the live output below, you can see that the first paragraph has gone wrong, because the browser thinks that the second instance of
is starting a new paragraph. The second paragraph looks fine, because we have replaced the angle brackets with character references.
In HTML, you define a paragraph using the
element.
In HTML, you define a paragraph using the
 element.
Note: A chart of all the available HTML character entity references can be found on Wikipedia: List of XML and HTML character entity references.
HTML comments
In HTML, as with most programming languages, there is a mechanism available to write comments in the code — comments are ignored by the browser and invisible to the user, and their purpose is to allow you to include comments in the code to say how your code works, what the different parts of the code do, etc. This can be very useful if you return to a code base that you've not worked on for six months, and can't remember what you did — or if you hand your code over to someone else to work on.
To turn a section of content inside your HTML file into a comment, you need to wrap it in the special markers , for example:

I'm not inside a comment

As you can see below, the first paragraph appears in the live output, but the second one doesn't.
I'm not inside a comment
Summary
You've reached the end of the article — we hope you enjoyed your tour of the very basics of HTML! At this point you should understand what the language looks like, how it works at a basic level, and be able to write a few elements and attributes. This is a perfect place to be right now, as in subsequent articles in the module we will go into some of the things you have already looked at in a lot more detail, and introduce some new features of the language. Stay tuned!
Note: At this point, as you start to learn more about HTML, you might also want to start to explore the basics of Cascading Style Sheets, or CSS. CSS is the language you use to style your web pages (whether e.g. changing the font or colors, or altering the page layout). HTML and CSS go very well together, as you'll soon discover.
Reference
All the documentation in this page is taken from MDN


We examine mices!
- strategize holistic markets
- iterate virtual web services
- aggregate real-time methodologies
- implement virtual synergies
- morph turn-key schemas
- extend scalable e-business
- aggregate bricks-and-clicks functionalities
- synergize viral ROI
- brand killer web services


More Recipes
Home
Sign Up
Sign In
John
Profile
Add Recipe
Category
Favorite Recipes
My Recipes
My Categories
Name:
Favorite Recipe:
Select favorite recipe
Party rice
Fried rice and plantain
Name
Category
Party jollof
Occasions
Mark
Otto
Mark
Otto
Mark
Otto


tutorial 2 -- hello world γ
This time is parameter of semantic action.
The Grammar File
%token Hello<std::string> World<std::string>; %namespace hello_world; %dont_use_stl; HelloWorld<std::string> : [Greet] Hello(0) World(1);
The difference from hello1
are two points:
- There is a type with token.
- There are two parameters with
Greet
.
At Line 1, capar will be recognize the types of
Hello
=> std::string
, World
=> std::string
by type specification for token.
By this, if token was given at later grammar, then the parser regards the type of the semantic value is the same type as associated one.
At Line 5, it specifies the parameter on Greet
call. The part of "(digit)" is just it.
This digit indicates n of n-th parameter (base is zero).
The symbols without "(digit)" won't be used on the call of its semantic action.
By this definition,
the 0-th parameter of Greet
is the value of Hello
,
the 1-th parameter is the value of World
, correspondingly.
The Calling File
#include <string> #include <iostream> #include "hello2.hpp" struct SemanticAction { void syntax_error(){} void stack_overflow(){} void upcast( std::string& x, const std::string& y ) { x = y; } void downcast( std::string& x, const std::string& y ) { x = y; } std::string Greet( const std::string& x, const std::string& y ) { std::cout << x << y << std::endl; return ""; } }; int main( int, char** ) { SemanticAction sa; hello_world::Parser< std::string, SemanticAction > parser( sa ); parser.post( hello_world::token_Hello, "Guten Tag, " ); parser.post( hello_world::token_World, "Welt" ); parser.post( hello_world::token_eof, "" ); return 0; }
The semantic actions became a bit compilicated.
This time introduced "downcast"
is a function to provide conversion
from type Value
of Parser
, to each type of symbol.
It's just a inverse of upcast
.
This time, "the type of the whole set of semantic values" is std::string
,
the "individual type" is also std::string
(Either of Hello
, World
, HelloWorld
is std::string
type).
Thus it's just one line of "void downcast( std::string& x, const std::string& y ) { x = y; }"
.
The signature of Greet
is given as below:
std::string Greet( const std::string& x, const std::string& y );
As the grammar file specified, x
indicates the value associated to Hello
,
y
indicates the value associated to World
, correspondingly.
And then, the return value of this function is associated to HelloWorld
by the parser.
This time, the main
function passes a value of "Guten Tag, ", "Welt"
when token is post
'ed.
That is, this value is used as the associated value to Hello
and World
on HelloWorld
acceptance.
Execution
% ./hello2 Guten Tag, Welt


- GamePlay - Class in entities
-
Observable Model for the Risk Game
Contains Vectors of relevant class entities, such as continents, countries and players that has been created by the loadmap function from
the controller
Observed by the MapUI JLabels to update information on the current game status
public methods within GamePlay is called by the controller while processing user inputs from the UI during game play
Attributes can only be accessed by getters and setters from the controller
handles change of game data and state and reflects to relevant observers
- GamePlay() - Constructor for class entities.GamePlay
-
Empty default ctor
- getAddFlag() - Method in class entities.GamePlay
-
returns
- getAlertType() - Method in class entities.GamePlay
-
Getter for alert type for observers
- getArmyNum() - Method in class entities.Country
-
Getter of armyNum
- getArmyToPlace() - Method in class entities.GamePlay
-
Getter for army to place
- getArmyToPlace() - Method in class entities.Player
-
Getter for army to place
- getAttackDice() - Method in class entities.GamePlay
-
Get the number of attack dice that has been set by the attacker
- getAttacker() - Method in class entities.GamePlay
-
Getter for the current attacking country
- getCardView() - Method in class entities.Card
-
- getColor() - Method in class entities.Continent
-
Getter for the Continent's color
- getColor() - Method in class entities.Player
-
Getter for Player's assigned Color
- getColorStr() - Method in class entities.Player
-
Getter for player's color String
- getContinent() - Method in class entities.Country
-
Getter of the Continent this Country belongs to
- getContinents() - Method in class entities.GamePlay
-
Getter for vector of continent
- getContinentsCountries() - Method in class entities.Continent
-
Getter for list of countries
- getCount() - Method in class ui.labels.CardView
-
Getter of counter
- getCountries() - Method in class controller.Controller
-
Getter for countries parsed in from the map
- getCountries() - Method in class entities.GamePlay
-
Getter for vector of countries
- getDefender() - Method in class entities.GamePlay
-
Getter for the current defending country
- getFilesLoad() - Method in class controller.Controller
-
Getter for all files uses for the map load
- getGame() - Method in class controller.Controller
-
Getter for the game play model
- getID() - Method in class entities.Continent
-
Getter for Continent id
- getID() - Method in class entities.Country
-
Getter of country's id
- getID() - Method in class entities.Player
-
Getter for player's id
- getImage() - Method in class entities.Card
-
- getLabel() - Method in class entities.Country
-
Getter of CountryObsLabel l
- getLinkCountries() - Method in class entities.Country
-
Getter of surrounding Country Vector
- getName() - Method in class entities.Continent
-
Getter for Continent name
- getName() - Method in class entities.Country
-
Getter of countryName
- getOutcome() - Method in class entities.GamePlay
-
Getter for outcome after a player action
- getOwnCard() - Method in class entities.Player
-
Getter of owned card
- getOwnContinent() - Method in class entities.Player
-
Getter for vector of owned continent
- getOwner() - Method in class entities.Country
-
Getter for owner of Country
- getPhase() - Method in class entities.GamePlay
-
Getter for phase attribute
- getPlayer() - Method in class entities.GamePlay
-
Getter for current Player
- getPlayerID() - Method in class entities.GamePlay
-
Getter for current player ID
- getPlayerIndex() - Method in class entities.GamePlay
-
Getter of player index
- getPlayers() - Method in class entities.GamePlay
-
Getter for vector of players
- getRandColor() - Method in class ui.Initial
-
Get random color from List colorList
- getRepresent() - Method in class ui.labels.CardView
-
Getter of card it is represented
- getTotalCountriesNumber() - Method in class entities.Player
-
Getter of total countries number
- getTradeTimes() - Method in class entities.Player
-
Getter for trade_times,
- getType() - Method in class entities.Card
-
- getValue() - Method in class entities.Continent
-
During phase one, when a player owns all countries in this Continent, player will be rewarded
an additional army equivalent to the continent's value
- getXY() - Method in class entities.Country
-


{{/*
NOTE: Attempted to use - if and .Site.Menus.main (eq .Site.SectionPagesMenu "main")
But Hugo complains about lack of SectionPagesMenu variable. It isn't accessible through SiteInfo.
SEE ALSO: "NOTE: on precedence..." at foot of this file.
SEE ALSO: header/nav.html
*/}}
{{ if .Site.Menus.main }}
{{/* Section Menu for Lazy Bloggers */}}
{{ else }}
{{/* Default HugoModo menu */}}
{{ end }}
{{/*
NOTE: on precedence...
'main' > 'lazy' > 'default'
If default is always fallen back to... how would one set a menu to not display at all?
Typically one would leave it out of their markup. However, we have it in our markup.
Okay, we'll assume for now that everybody wants a menu.
*/}}


Upon login, fill the questionnare which contains your personal details as well as your interests
Book an appointment with a counsellor once you have filled the questionnare.
Talk to the counsellor who can help you make an informed decison about your future.


Create an Html Element
name of element like div, span etc
element id
classes assigned to element like in html class attribute format
styles assigned to element like in html style attribute format
classes assigned to element like in html class attribute format
element id
styles assigned to element like in html style attribute format
name of element like div, span etc
Add a class to element
class name
Add a style rule to element
class name
Set class of element with a chainable method
string of classes with empty space separator
Set id of element with a chainable method
id of element
Initialize create and initialize element
Remove a class by element
class name
Remove a style rule by element
class name
Set class attribute of element like in html class attribute format
string of classes with empty space separator
Set id of element
id of element
Set style attribute of element like in html style attribute format
string of style with ';' separator
Set style of element with a chainable method
string of style with ';' separator
Generated using TypeDoc
Core Html Element, contruct html element and provide basic methods for set and get property and element attribute


#{extends 'main.html' /} #{set title:'Movie detail' /}
You currently rate this a ${user_rating.score}
You did not rate this movie, yet.
We predict you will rate this movie ${prediction}.


Take your kid to this film The Iron Giant
By Ross Anthony
What if a gun forgot it was a gun?
A weapon in the form of a large robot with a big appetite for metal falls to Earth from outer space.
Without the gun part, this movie would play so much like every other alien-falls-to-Earth story we've seen, that one could hardly get too excited about it. Child finds alien, teaches alien to speak, hides alien from government that wants to kill it ... you know the rest. There's even a super cliche, slightly slanted scene where the robot learns to appreciate nature by connecting with a deer in the woods.
But, "Iron Giant" is a gun and he's got a pertinent choice to make. When the army comes to blow him away, will he fight back with all his alien might? No one would blame him ... he'd certainly have the right to defend himself. Or would he consider all he had just learned about the magic of life and decide to use his power in some more "humanitarian" (though metallic) kind of way?
This is an important concept to have set before our kids (and a good reminder for us, too): 1) You are powerful. 2) You can use that power destructively or constructively. 3) Which are you going to choose?
Of course, the slant of this particular picture is the more selfless choice. In fact, less than subtle messages like: "If you're good you have a soul" and "It's not bad to die, but it's bad to kill" and "Souls don't die" and "Guns kill" are the nuts and bolts of the story.
The animation is more in the old style which befits this 1950's tale. The giant itself is charming. The voice talent hit their marks, Harry Connick Jr. standing out as the most interesting, while a fair Tim Allen sound-a-like speaks for the ornery FBI agent hassling our Iron Giant's small friend.
Despite the fact that "Iron Giant" is more of a relationship (child buddy) film than an animated action flick, kids will absolutely love it and they'll be going home chewing on a valuable chunk of "heavy mental" of their own.
Voices: Jennifer Anisten, Harry Connick Jr., Eli Marienthal, James Gammon, Vin Diesel. Screenplay by Tim McCanlies, Based on book by Ted Hughes. Produced by Allison Abbate and Des McAnuff at Warner Brothers. Rated PG.
Kid's Grade..........................A+ Adult's Grade..........................B+
-- Copyright © 1999 Ross Anthony, currently based in Los Angeles, has scripted and shot documentaries, music videos, and shorts in 35 countries across North America, Europe, Africa and Asia. For more reviews visit: http://RossAnthony.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


The FormatComb
structure provides well-typed formating (or unparsing)
combinators in the style of Olivier Danvy’s
Functional Unparsing work.
The idea is to use combinators for constructing something akin to
the format string of C's printf
function. The difference is, however,
that our formats are not strings. Instead, format fragments have
meaningful types, and passing them to the format
function results
in a curried function whose arguments have precisely the types that
correspond to argument-consuming parts of the format. (Such
argument-consuming parts are similar to the conversion-specifications
the Format
structure.)
There is an underlying notion of "abstract formats" of type 'a format
,
but the user operates at the level of "format fragments," which
have type ('a, 'b) fragment
and are typically polymorphic
in 'a
(where 'b
is instantiated to some type containing 'a
).
Fragments are functions from formats to formats and can be composed
freely using the infix function-composition operator (o
). This
form of format composition translates to a corresponding concatenation
of the resulting output.
Fragments are composed from two kids of primitve fragments called elements and glue, respectively. An element is a fragment that consumes some argument (which thanks to the typing magic appears as a curried argument when the format gets executed). Glue are fragments that do not consume arguments but merely insert fixed text (fixed at format construction time) into the output.
There are also adjustment operations that pad, trim, or fit the output of entire fragments (primitive or not) to a given size.
Matthias Blume wrote the code for this module.
Synopsis
signature FORMAT_COMB
structure FormatComb : FORMAT_COMB
Interface
type 'a format
type ('a, 'b) fragment = 'a format -> 'b format
type 'a glue = ('a, 'a) fragment
type ('a, 't) element = ('a, 't -> 'a) fragment
type 'a gg
val format : (string, 'a) fragment -> 'a
val format' : (string list -> 'b) -> ('b, 'a) fragment -> 'a
val using : ('t -> string) -> ('a, 't) element
val int : ('a, int) element
val real : ('a, real) element
val bool : ('a, bool) element
val string : ('a, string) element
val string' : ('a, string) element
val char : ('a, char) element
val char' : ('a, char) element
val int' : StringCvt.radix -> ('a, int) element
val real' : StringCvt.realfmt -> ('a, real) element
val list : ('a, 'x) element -> ('a, 'x list) element
val option : ('a, 'x) element -> ('a, 'x option) element
val seq : (('x * 'a gg -> 'a gg) -> 'a gg -> 's -> 'a gg)
-> 'a glue
-> ('a, 'x) element
-> ('a, 's) element
val glue : ('a, 't) element -> 't -> 'a glue
val elem : ('t -> 'a glue) -> ('a, 't) element
val nothing : 'a glue
val text : string -> 'a glue
val sp : int -> 'a glue
val nl : 'a glue
val tab : 'a glue
val listg : ('t -> 'a glue) -> ('t list -> 'a glue)
val optiong : ('t -> 'a glue) -> ('t option -> 'a glue)
val seqg : (('x * 'a gg -> 'a gg) -> 'a gg -> 's -> 'a gg)
-> 'a glue
-> ('x -> 'a glue)
-> 's -> 'a glue
type place
val left : place
val center : place
val right : place
val pad : place -> int -> ('a, 't) fragment -> ('a, 't) fragment
val trim : place -> int -> ('a, 't) fragment -> ('a, 't) fragment
val fit : place -> int -> ('a, 't) fragment -> ('a, 't) fragment
val padl : int -> ('a, 't) fragment -> ('a, 't) fragment
val padr : int -> ('a, 't) fragment -> ('a, 't) fragment
Description
type 'a format
-
An abstract type; values of this type are internal to the implementation.
type ('a, 'b) fragment = 'a format -> 'b format
-
A fragment is a function from formats to formats.
type 'a glue = ('a, 'a) fragment
-
A
glue
fragment insertes text into the output without consuming and argument. type ('a, 't) element = ('a, 't -> 'a) fragment
-
An
element
fragment consumes an argument of type't
, converts it to a string, and inserts the result in the output. type 'a gg
-
An abstract helper type that is internal to the implementation.
val format : (string, 'a) fragment -> 'a
-
format fmt
returns a format function as defined by the expressionfmt
that will produce a string result when applied to the necessary arguments. val format' : (string list -> 'b) -> ('b, 'a) fragment -> 'a
-
format' consumer fmt
returns a format function as defined by the expressionfmt
that will invoke theconsumer
on the list of strings produced by formating when applied to the necessary arguments. (The argument to theconsumer
is a string list to avoid premature string concatenation in the implementation). Note that theformat
function can be defined in terms offormat'
as follows:
val format = format' String.concat
(* Make a type-specific element given a toString function for this type *) `[.kw]#val# using : ('t \-> string) \-> ('a, 't) element`:: `using tos` returns an element fragment that represents the given "value-to-string" conversion.
val int : ('a, int) element
-
an element fragment for formating integers; it is equivalent to the expression
using Int.toString
. val int' : StringCvt.radix -> ('a, int) element
-
int' radix
returns an element fragment for formating integers in the specifiedradix
. It is equivalent to the expressionusing (Int.fmt radix)
. val real : ('a, real) element
-
an element fragment for formating reals; it is equivalent to the expression
using Real.toString
. val real' : StringCvt.realfmt -> ('a, real) element
-
real' rf
returns an element fragment for formating reals with the specified format. It is equivalent to the expressionusing (Real.fmt rf)
. val bool : ('a, bool) element
-
an element fragment for formating booleans; it is equivalent to the expression
using Bool.toString
. val string : ('a, string) element
-
an element fragment for formating raw strings; it is equivalent to the expression
using (fn x ⇒ x)
. val string' : ('a, string) element
-
an element fragment for formating strings with escapes; it is equivalent to the expression
using String.toString
. val char : ('a, char) element (* using String.str *)
-
an element fragment for formating raw characters; it is equivalent to the expression
using String.str
. val char' : ('a, char) element (* using Char.toString *)
-
an element fragment for formating characters with escapes; it is equivalent to the expression
using Char.toString
.(* "polymorphic" elements *)
val list : ('a, 'x) element -> ('a, 'x list) element (* "[", ", ", "]" *)
-
list elemFmt
returns an element fragment that formats lists of items using theelemFmt
element fragment to format items. The list will be enclosed in brackets (“`[” “
]`”) with elements separated by commas. val option : ('a, 'x) element -> ('a, 'x option) element
-
option elemFmt
returns an element fragment that formats optional items using theelemFmt
element fragment to format the item value. For an argument ofNONE
, the string"NONE"
is returned, while for an argument ofSOME v
, the string"SOME(s)"
is returned, wheres
is the result of formattingv
usingelemFmt
. val seq : (('x * 'a gg -> 'a gg) -> 'a gg -> 's -> 'a gg) -> 'a glue -> ('a, 'x) element -> ('a, 's) element
-
something
val glue : ('a, 't) element -> 't -> 'a glue
-
glue fmt arg
returns a glue element that renders as the string that results from usingfmt
to convertarg
to a string. val elem : ('t -> 'a glue) -> ('a, 't) element
-
elem glueGen
returns an element for rendering arguments to theglueGen
function. This function is the inverse ofglue
and is useful for extending the set of combinators. val nothing : 'a glue
-
A glue fragment that renders as the empty string.
val text : string -> 'a glue
-
text s
returns a glue fragment that renders as the texts
. val sp : int -> 'a glue
-
sp n
returns a glue fragment that renders asn
space characters. val nl : 'a glue
-
A glue fragment that renders as a newline character.
val tab : 'a glue
-
A glue fragment that renders as a tab character.
val listg : ('t -> 'a glue) -> ('t list -> 'a glue)
-
something
val optiong : ('t -> 'a glue) -> ('t option -> 'a glue)
-
something
val seqg : (('x * 'a gg -> 'a gg) -> 'a gg -> 's -> 'a gg) -> 'a glue -> ('x -> 'a glue) -> 's -> 'a glue
-
something
type place
-
An abstract type that represents how to pad or trim of string.
val left : place
-
Pad or trim the left side of a string.
val center : place
-
Pad or trim both sides of a string.
val right : place
-
Pad or trim the left side of a string.
val pad : place -> int -> ('a, 't) fragment -> ('a, 't) fragment
-
pad place n frag
wraps the fragmentfrag
with padding to bring the total with to no fewer thann
characters. Theplace
specifies where padding spaces will be added. Padding never reduces the size of the result.
val trim : place -> int -> ('a, 't) fragment -> ('a, 't) fragment
-
trim place n frag
wraps the fragmentfrag
with a trimming operation to bring the total with to no more thann
characters. Theplace
specifies where trimming occurs. Trimming never increases the size of the result.
val fit : place -> int -> ('a, 't) fragment -> ('a, 't) fragment
-
fit place n frag
wraps the fragmentfrag
with an operation that guarantees the result will be exactlyn
characters by either padding or trimming as necessary. val padl : int -> ('a, 't) fragment -> ('a, 't) fragment
-
padl n frag
is equivalent topad left n frag
. val padr : int -> ('a, 't) fragment -> ('a, 't) fragment
-
padr n frag
is equivalent topad right n frag
.
Examples
Here are examples on how to use this facility.
format nothing (* ==> "" *)
format int 1234 (* ==> "1234" *)
format (text "The square of " o int o text " is " o int o text ".") 2 4
(* ==> "The square of 2 is 4." *)
format (int o bool o char) 1 true #"x"
(* ==> "1truex" *)
format (glue string "glue vs. " o string o glue int 42 o sp 5 o int)
"ordinary text " 17
(* ==> "glue vs. ordinary text 42 17" *)
format (pad left 6 int) 1234 (* ==> " 1234" *)
format (pad center 6 int) 1234 (* ==> " 1234 " *)
format (pad right 6 int) 1234 (* ==> "1234 " *)
format (trim left 2 int) 1234 (* ==> "34" *)
format (trim center 2 int) 1234 (* ==> "23" *)
format (trim right 2 int) 1234 (* ==> "12" *)
format (fit left 3 int) 12 (* ==> " 12" *)
format (fit left 3 int) 123 (* ==> "123" *)
format (fit left 3 int) 1234 (* ==> "234" *)


Source code for mango.application.main_driver.filters
import mango
import sys
import inspect
if sys.platform.startswith('linux'):
import DLFCN as dl
_flags = sys.getdlopenflags()
sys.setdlopenflags(dl.RTLD_NOW|dl.RTLD_GLOBAL)
from . import _mango_open_main_driver as _mango_open_main_driver_so
if (mango.haveRegistration):
from . import _mango_reg_main_driver as _mango_reg_main_driver_so
if (mango.haveRestricted and (not mango.haveReconstructionOnly)):
from . import _mango_rest_main_driver as _mango_rest_main_driver_so
if (mango.haveReconstruction):
from . import _mango_recon_main_driver as _mango_recon_main_driver_so
if (mango.haveContrib):
from . import _mango_contrib_main_driver as _mango_contrib_main_driver_so
sys.setdlopenflags(_flags)
else:
from . import _mango_open_main_driver as _mango_open_main_driver_so
if (mango.haveRegistration):
from . import _mango_reg_main_driver as _mango_reg_main_driver_so
if (mango.haveRestricted and (not mango.haveReconstructionOnly)):
from . import _mango_rest_main_driver as _mango_rest_main_driver_so
if (mango.haveReconstruction):
from . import _mango_recon_main_driver as _mango_recon_main_driver_so
if (mango.haveContrib):
from . import _mango_contrib_main_driver as _mango_contrib_main_driver_so
from mango.application.main_driver._mango_main_driver import MainDriverFilter
from ._mango_open_main_driver import *
if (mango.haveRegistration):
from ._mango_reg_main_driver import *
if (mango.haveRestricted and (not mango.haveReconstructionOnly)):
from ._mango_rest_main_driver import *
if (mango.haveReconstruction):
from ._mango_recon_main_driver import *
if (mango.haveContrib):
from ._mango_contrib_main_driver import *
_filterClsList = []
for _member in inspect.getmembers(sys.modules[__name__]):
if (inspect.isclass(_member[1]) and issubclass(_member[1], MainDriverFilter)):
_filterClsList.append(_member)
_tableEntryWidth = max([len(_name) for _name in [_m[0] for _m in _filterClsList]])
_rowEndStr = "+-" + ("-"*(_tableEntryWidth)) + "-+\n"
_filtClsDocStr = ""
_filtClsDocStr += _rowEndStr
for _member in _filterClsList:
_filtClsDocStr += ("| %%-%ds |\n" % _tableEntryWidth) % _member[0]
_filtClsDocStr += _rowEndStr
__doc__ = \
"""
=========================================================================
Main driver filter classes (:mod:`mango.application.main_driver.filters`)
=========================================================================
.. currentmodule:: mango.application.main_driver.filters
Classes
=======
.. autosummary::
:toctree: generated/
MainDriverFilter - Base class for main-driver filters.
Filter List
===========
%s
""" % _filtClsDocStr
__all__ = [s for s in dir() if not s.startswith('_')]


<lcAnswerOptionGroup2>
The <lcAnswerOptionGroup2>
element provides a container for the options
for a true-false, single-select, or multiple-select assessment interaction. This element
replaces the <lcAnswerOptionGroup>
element in DITA 1.2.
Category: Interactions domain content elements


Product Analytics
-
Top 10 Purchased Products
The most preferred products for the customers. Each bar represents the total number of order per product. -
Top 10 Purchased Categories
The most preferred product categories for the customers. Each bar represents the total number of order per product category. -
Most Combined Products
Each product pairs are counted a order and Total number of order count per product pairs are calculated.


# Adding Quick Fixes ## Introduction When your detector reports an incident, it can also provide one or more "quick fixes“, which are actions the users can invoke in the IDE (or, for safe fixes, in batch mode) to address the reported incident. For example, if the lint check reports an unused resource, a quick fix could offer to remove the unused resource. In some cases, quick fixes can take partial steps towards fixing the problem, but not fully. For example, the accessibility lint check which makes sure that for images you set a content description, the quickfix can offer to add it -- but obviously it doesn't know what description to put. In that case, the lint fix will go ahead and add the attribute declaration with the correct namespace and attribute name, but will leave the value up to the user (so it uses a special quick fix provided by lint to place a TODO marker as the value, along with selecting just that TODO string such that the user can type to replace without having to manually delete the TODO string first.) ## The LintFix builder class The class in lint which represents a quick fix is `LintFix`. Note that `LintFix` is **not** a class you can subclass and then for example implement your own arbitrary code in something like a `perform()` method. Instead, `LintFix` has a number of builders where you *describe* the action that you would like the quickfix to take. Then, lint will offer that quickfix in the IDE, and when the user invokes it, lint runs its own implementation of the various descriptors. The historical reason for this is that many of the quickfixes in lint depended on machinery in the IDE (such as code and import cleanup after an edit operation) that isn't available in lint itself, along with other concepts that only make sense in the IDE, such as moving the caret, opening files, selecting text, and so on. More recently, this is also used to persist quickfixes properly for later reuse; this is required for [partial analysis](partial-analysis.md.html). ## Creating a LintFix Lint fixes use a ”fluent API“; you first construct a `LintFix`, and on that method you call various available type methods, which will then further direct you to the allowed options. For example, to create a lint fix to set an XML attribute of a given name to ”true“, use something like this: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~kotlin LintFix fix = fix().set(null, "singleLine", "true").build() ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Here the `fix()` method is provided by the `Detector` super class, but that's just a utility method for `LintFix.fix()` (or in older versions, `LintFix.create()`). There are a number of additional, common methods you can set on the `fix()` object: * `name`: Sets the description of the lint fix. This should be brief; it's in the quickfix popup shown to the user. * `sharedName`: This sets the ”shared“ or ”family“ name: all fixes in the file will with the same name can be applied in a single invocation by the user. For example, if you register 500 ”Remove unused import“ quickfixes in a file, you don't want to force the user to have to invoke each and every one. By setting the shared name, the user will be offered to **Fix All *$family name* problems in the current file**, which they can then perform to have all 500 individual fixes applied in one go. * `autoFix`: If you get a lint report and you notice there are a lot of incidents that lint can fix automatically, you don't want to have to go and open each and every file and all the fixes in the file. Therefore, lint can apply the fixes in batch mode; the Gradle integration has a `lintFix` target to perform this, and the `lint` command has an `--apply-suggestions` option. However, many quick fixes require user intervention. Not just the ones where the user has to choose among alternatives, and not just the ones where the quick fix inserts a placeholder value like TODO. Take for example lint's built-in check which requires overrides of a method annotated with `@CallSuper` to invoke `super.` on the overridden method. Where should we insert the call -- at the beginning? At the end? Therefore, lint has the `autoFix` property you can set on a quickfix. This indicates that this fix is ”safe“ and can be performed in batch mode. When the `lintFix` target runs, it will only apply fixes marked safe in this way. ## Available Fixes The current set of available quick fix types are: * `fix().replace`: String replacements. This is the most general mechanism, and allows you to perform arbitrary edits to the source code. In addition to the obvious ”replace old string with new“, the old string can use a different location range than the incident range, you can match with regular expressions (and perform replacements on a specific group within the regular expression), and so on. This fix is also the most straightforward way to **delete** text. It offers some useful cleanup operations: - Source code cleanup, which will run the IDE's code formatter on the modified source code range. This will apply the user's code preferences, such as whether there should be a space between a cast and the expression, and so on. - Import cleanup. That means that if you are referencing a new type, you don't have to worry about checking whether it is imported and if not adding an import statement; you can simply write your string replacements using the fully qualified names, and then tag the quickfix with the import cleanup option, and when the quickfix is performed the import will be added if necessary and all the fully qualified references replaced with simple names. And this will also correctly handle the scenario where the symbols cannot be replaced with simple names because there is a conflicting import of the same name from a different package. Normally, you should write your replacement source code using fully qualified names, and then apply `shortenNames` to the quickfix to tell lint to replace fully qualified names with imports; don't try to write your quickfix to also add the import statements on its own. There's a possibility that a given name cannot be imported because it's already importing the same name for a different namespace. When using fully qualified names, lint will specifically handle this. In some cases you cannot use fully qualified names in the code snippet; this is the case with Kotlin extension functions for example. For that scenario, the replacement quickfix has an `imports` property you can use to specify methods (and classes and fields) to import at the same time. * `fix().annotate`: Annotating an element. This will add (or optionally replace) an annotation on a source element such as a method. It will also handle import management. * `fix().set`: Add XML attributes. This will insert an attribute into the given element, applying the user's code style preferences for where to insert the attribute. (In Android XML for example there's a specific sorting convention which is generally alphabetical, except layout params go before other attributes, and width goes before height.) You can either set the value to something specific, or place the caret inside the newly created empty attribute value, or set it to TODO and select that text for easy type-to-replace. !!! Tip If you use the `todo()` quickfix, it's a good idea to special case your lint check to deliberately not accept ”TODO“ as a valid value. For example, for lint's accessibility check which makes sure you set a content description, it will complain both when you haven't set the content description attribute, **and** if the text is set to ”TODO“. That way, if the user applies the quickfix, which creates the attribute in the right place and moves the focus to the right place, the editor is still showing a warning that the content description should be set. * `fix().unset`: Remove XML attribute. This is a special case of add attribute. * `fix().url`: Show URL. In some cases, you can't ”fix“ or do anything local to address the problem, but you really want to direct the user's attention to additional documentation. In that case, you can attach a ”show this URL“ quick fix to the incident which will open the browser with the given URL when invoked. For example, in a complicated deprecation where you want users to migrate from one approach to a completely different one that you cannot automate, you could use something like this: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~kotlin val message = "Job scheduling with `GcmNetworkManager` is deprecated: Use AndroidX `WorkManager` instead" val fix = fix() .url("https://developer.android.com/topic/libraries/architecture/workmanager/migrating-gcm") .build() ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ## Combining Fixes You might notice that lint's APIs to report incidents only takes a **single** quick fix instead of a list of fixes. But let's say that it *did* take a list of quick fixes. - Should they *all* be performed as a single unit? That makes sense if you're trying to write a quickfix which performs multiple string replacements. - Or should they be offered as separate alternatives for the user to choose between? That makes sense if the incident says for example that you must set at least one attribute among three possibilities; in this case we may want to add quickfixes for setting each attribute. Both scenarios have their uses, so lint makes this explicit: - `fix().composite`: create a ”composite“ fix, which composes the fix out of multiple individual fixes, or - `fix().alternatives`: create an ”alternatives“ fix, which holds a number of individual fixes, which lint will present as separate options to the user. Here's an example of how to create a composite fix, which will be performed as a unit; here we're both setting a new attribute and deleting a previous attribute: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~kotlin val fix = fix().name("Replace with singleLine=\"true\"") .composite( fix().set(ANDROID_URI, "singleLine", "true").build(), fix().unset(namespace, oldAttributeName).build() ) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ And here's an example of how to create an alternatives fix, which are offered to the user as separate options; this is from our earlier example of the accessibility check which requires you to set a content description, which can be set either on the ”text“ attribute or the "contentDescription” attribute: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~kotlin val fix = fix().alternatives( fix().set().todo(ANDROID_URI, "text").build(), fix().set().todo(ANDROID_URI, "contentDescription") .build()) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ## Refactoring Java and Kotlin code It would be nice if there was an AST manipulation API, similar to UAST for visiting ASTs, that quickfixes could use to implement refactorings, but we don't have a library like that. And it's unlikely it would work well; when you rewrite the user's code you typically have to take language specific conventions into account. Therefore, today, when you create quickfixes for Kotlin and Java code, if the quickfix isn't something simple which would work for both languages, then you need to conditionally create either the Kotlin version or the Java version of the quickfix based on whether the source file it applies to is in Kotlin or Java. (For an easy way to check you can use the `isKotlin` or `isJava` package level methods in `com.android.tools.lint.detector.api`.) However, it's often the case that the quickfix is something simple which would work for both; that's true for most of the built-in lint checks with quickfixes for Kotlin and Java. ## Regular Expressions and Back References The `replace` string quick fix allows you to match the text to with regular expressions. You can also use back references in the regular expression such that the quick fix replacement text includes portions from the original string. Here's an example from lint's `AssertDetector`: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~kotlin linenumbers val fix = fix().name("Surround with desiredAssertionStatus() check") .replace() .range(context.getLocation(assertCall)) .pattern("(.*)") .with("if (javaClass.desiredAssertionStatus()) { \\k<1> }") .reformat(true) .build() ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The replacement string's back reference above, on line 5, is \k<1>. If there were multiple regular expression groups in the replacement string, this could have been \k<2>, \k<3>, and so on. Here's how this looks when applied, from its unit test: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~kotlin lint().files().run().expectFixDiffs( """ Fix for src/test/pkg/AssertTest.kt line 18: Surround with desiredAssertionStatus() check: @@ -18 +18 - assert(expensive()) // WARN + if (javaClass.desiredAssertionStatus()) { assert(expensive()) } // WARN """ ) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ## Emitting quick fix XML to apply on CI Note that the `lint` has an option (`--describe-suggestions`) to emit an XML file which describes all the edits to perform on documents to apply a fix. This maps all quick fixes into chapter edits (including XML logic operations). This can be (and is, within Google) used to integrate with code review tools such that the user can choose whether to auto-fix a suggestion right from within the code review tool.


Lesson Plan Title: Client Side Filtering
Concept / Topic To Teach:
It is always a good practice to send to the client only information which they are supposed to have access to. In this lesson, too much information is being sent to the client, creating a serious access control problem.General Goal(s):
For this exercise, your mission is exploit the extraneous information being returned by the server to discover information to which you should not have access.


I designed and built this torque loader to load torque wrenches at a metrology lab I worked at. It allows you to easily apply any desired torque to the wrench while it's attached to the transducer. This saved the company about $10,000. Other photos of the lab are also on this page.


--- layout: page title: "JPA Querying Performance Tips" comments: true published: true date: 2017-07-31 19:20:00 -0500 categories: jpa query performance tips ---
Hello readers. It's been quite a while!
In this post, I will share some tips that will help your application perform fast while using JPA, and Hibernate as a JPA provider. JPA can cause quite an overhead if it's not used correctly from the start of the project. In some companies, it has actually gotten such a bad reputation to the point that a lot of operations has to be done using pure JDBC.
To make sure that querying using JPA performs well, basically it boils down to:
Eager loading happens for @ManyToOne annotated attributes by default, and when declared explicitly with FetchType.EAGER. What this means is that every time an entity is retrieved, another select is issued to the database for every eager attribute.
For that reason, I always anotate @OneToMany and @ManyToOne attributes with FetchType.LAZY. Whenever I need to load the lazy attribute, I use the "fetch" keyword, and in some cases a seperate Query can be issued as well. For example:
{% highlight sql %} SELECT per.name FROM Person per JOIN FETCH per.addressList adr {% endhighlight %}In 99% of the cases where you need to query a big table, you don't have to retrieve all the data. That said, unless you are querying a small table that you know won't increase exponentially in size, always paginate your query using the following syntax:
{% highlight java %} Query query = entityManager.createQuery("SELECT per from Person per"); int pageNumber = 1; int pageSize = 10; query.setFirstResult((pageNumber - 1) * pageSize); query.setMaxResults(pageSize); ListIf you querying a table that has more than 30 attributes, this syntax can slow down the database. There's also a huge slow down when one of those attributes is a BLOB or CLOB types. I've seen a page that loaded a BLOB attribute unnecessarily taking 30s to load, to less than 1s after changing the query to select specific attributes.
In these cases it is preferred that you create a Value Object that will hold specific values from the table.
Usually it is better to fetch all the data you need right from the start, using join fetch for example. But that's not always possible. But whatever you do, don't query in a loop.
Try as much as you can to make a query that will fetch all the data (paged if there's too much registers). Just be careful of using the IN to fetch de dependencies. Generally IN will slow down the database if used with 100+ registers.
There are some techniques that are faster than using IN, such as:
The database can do a lot of work for you. So use it in your favor. If a process can be optimized to fetch/insert all the data in one or more SQL queries, that would be too slow if done individually in Java code, don't be afraid to use Native Queries.
For example, a process done in Java like this:
Could be a lot faster if optimized and done like this:
As stated in this article, JPA can be used without performance bottlenecks, if the correct use of it is enforced. I hope the information here presented was useful! See you next time!


NO-STATUS
This example demonstrates handling of input events in PPAPI.
Each time an input event happens in the context of the gray box, the main thread in the embedded NaCl module converts it from a Pepper input event to a non-Pepper event and puts this custom event onto a shared queue. A worker thread in the embedded NaCl module reads events from the queue, and converts each event to a string and then uses CallOnMainThread to post a message describing the event back to JavaScript, which prints a message to the JavaScript console in Chrome and to a string on the page.
If you press the 'Kill worker thread and queue' button, then the main thread (which puts events on the queue) will call CancelQueue, indicating that the main thread will no longer put events on the queue. When the worker sees that the shared queue has been cancelled, the worker thread will terminate.
None


ccmatch -- Used to randomly match cases and controls based on specified criteria. For instance, if you wanted to randomly match cases and controls based on age, you can use ccmatch to specify age as a criterion on which to match cases and controls and it will match randomly by age. You can use multiple variables to match based on multiple criteria
ccmatch creates two variables:
match_id gives the id of the partner an individual has been matched to.
matched_pair Numbers pairs starting from one. Pairs will share the same number in this column (see example below).
Syntax
ccmatch variable_list, cc() id()
variable_list -- Specify variables you want each pair to share here.
cc(var) -- Specify the variable you use to identify cases and controls.
Example
match_id matched_pair name case_control > age a6 1 a2 0 > 15 a2 1 a6 1 > 15 a7 2 a4 0 > 16 a4 2 a7 1 > 16 a8 3 a5 0 > 17 a5 3 a8 1 > 17 a10 4 a1 0 > 19 a1 4 a10 1 > 19 . a3 0 > 15 . a9 1 > 18
The above output is an example of what match can do. The original data (name, case_control, age) is unchanged, except that it has been reordered The command used was:
ccmatch age, id(name) cc(case_control)
Age was specified following ccmatch to indicate that we wanted to match cases/control who are the same age.
The case/control variable is specified as an option using cc(), and the id of each individual is specified using id().
------------------------------------------------------------------------------- note I use individual in this document but it could be interchanged with the word 'observation' and meaning would be the same. This program should be used in cases where each row of your dataset constitutes a single individual. ------------------------------------------------------------------------------- Last Revised 12/18/12 Update - 12/18/12 - Huge performance improvement - works on extremely large datasets no > w.
Update - 06/27/12 - Fixed issue where a maximum of only 1600 individuals could be match > ed.
Initial Release - 12/18/11


women4women
home
Login
SignUp
employer
jobs
Full time
part time
internships
volunteering
counseling
contact
Featured Jobs
Job Title heading
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Mollitia...
Posted by Recruiter - 12/12/2014
View Details
Shortlist
Personal Asisstant
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Mollitia...
Posted by Recruiter - 12/12/2014
View Details
Shortlist
Job Title heading
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Mollitia...
Posted by Recruiter - 12/12/2014
View Details
Shortlist


The Hertzsprung–Russell diagram (HR Diagram) is a graph that relates the temperature of a group of stars, to their luminosity. The horizontal axis shows the temperature of the stars from greatest to lowest, reversed from a traditional plot. The vertical axis shows the luminosity of the stars. Since the magnitude of a star is related to its luminosity, and the color of a star is related to its temperature, and HR diagram might replace luminosity with magnitude, or color with temperature.
One can usually see a long diagonal line of stars going from top left to bottom right of the HR diagram, that is known as the
main sequence band, populated by stars known as
main sequence stars. Stars live most of their life in the
main sequence, and then transition onto the horizontal branch, red giant branch, and asymptotic giant branch. Which are the group of stars in the upper right section of the diagram. The small group of stars on the lower left corner are
white dwarfs.


Virtual Reality
2008-2009 2nd Semester
3rd Year
| Instructor: |
Lect. Dr. Rares Boian <rares at cs.ubbcluj.ro> |
Syllabus
News
| 2009-04-06: Updated the cars example. Download it from here. |
| 2009-03-05: Multi-sense VR helmet in development |
| 2009-03-05: The course website is active. See the Resources section on the bottom of the page. The rest of the content needs to be updated. |
Semester Projects
Graded Work
- Lab Projects
- The problems to be solved for each lab project will be assigned to students through the AMS portal. The access to the portal is done using the UNIX username and password
- The solutions must be uploaded into the AMS portal by the given deadline. A one-week extesion will be allowed, in which case the grade will be reduced by 2 points. Later uploads will be ignored.
- Semester Project
- The project's subject will be chosen by the students and submitted for approval to the instructor
- It is possible to work in groups of 2 or 3 but the projects need to be proportionally larger
Final grade calculation
FinalGrade = 0.4*LabProjectsAverage +
0.6*SemesterProject
Lab group division The
distribution of students into lab groups is done automatically such that
lab groups will be balanced in the number of students. Switching lab
groups is allowed only during the first two weeks of the semester provided
that the students have good reasons to request the switch and the switch
will keep the lab groups balanced.
Lab project handin rules
- The lab projects must work on the hardware and software facilities available in the CS department
- The projects will be presented to the lab instructor exclusively during the lab hours
- The solutions will be archived in ZIP format and will be uploaded to the AMS portal.
The access to the portal is done using the student's UNIX username and password.
- The handin of a lab project involves:
- Uploading the solution into the AMS portal.
- The upload must be done by the deadline specified in the portal.
The students are allowed and additional grace period of one week during which the project can still
be handed in, but the grade will be decreased with 2 points. Later uploads will be ignored.
- The lab project has to be graded by the lab instructor upon the students presentation.
- If any of (a), (b), or (c) are not satisfied the lab project is considered un-submitted and hence not graded.
Labs
| 1. |
VR Modeling Tools |
2009-02-27 |
| 2. |
Ray tracing - colored spheres |
2009-03-06 |
3. |
Ray tracing - spheres with lighting |
2009-03-13 |
| 4. |
OpenGL - articulated robot |
2009-03-20 |
| 5. |
OpenGL - articulated robot |
2009-03-27 |
| 6. |
Delta3D - articulated robot |
2009-04-03 |
| 7. |
Semester project work |
2009-04-10 |
| 8. |
Semester project work |
2009-04-17 |
| 9. |
Semester project work |
2009-05-01 |
| 10. |
Semester project work |
2009-05-08 |
| 11. |
Semester project work |
2009-05-15 |
| 12. |
Semester project presentations |
2009-05-22 |
Resources


PRINT & PLAY! Start printing as soon as you order!
{{ product['title'] }}
Price:
${{ product['price'] }}
{% if product['personalize'] %}
PERSONALIZE THIS GAME!
Find out how.
{% endif %}
Game Description
{{ product['description'] }}
{% if product['timeToPlay'] or product['players'] or product['winners'] %}
{% if product['timeToPlay'] %}
{% endif %}
{% if product['players'] %}
{% endif %}
{% if product['winners'] %}
{% endif %}
{% endif %}
Time:
{{ product['timeToPlay'] }}
Players:
{{ product['players'] }}
Winners:
{{ product['winners'] }}
Customer Reviews
{# Review bundle #}Rules of Play
{{ product['rulesOfPlay'] }}
What's Included When You Order
{{ product['whatsIncluded'] }}


Consulting
Our strength and years of delivery can make any of your projects a reality.
Utilising our modular software development approach, we are on a mission to create Artificial Intelligence assisted software solutions to solve real world problems.
Pathfinders.Ai is an Australian based and owned full stack dev machine learning consultancy that prides itself on its ability to drive solution driven results for our customers.
Our strength and years of delivery can make any of your projects a reality.
Work with a team of highly experienced consultants and data scientists to establish best AI practice.
We build reusable solutions with our modular development approach.
We deliver Ai endpoints and maintain our ML solutions.
At pathfinders we assess your daily activities and help improve and streamline them to improve your Business focus, output and bottom line.
Our strength in machine learning (ML) and artificial intelligence (AI) is also coupled with our full stack development capability, making us the complete partner for you.
We are able to leverage our vast Data Science & Full Stack Developer networks to find fantastic talent - at an affordable price.
Utilising our modular development approach, we can supply you with or build you a reusable solution which meets your needs but is also extendible to cater for your Business growth.
Our skilled Machine Learning and IT experts will work with your IT and Business during the design, build and deployment phases of your project and will ensure all our work and your IP is handed over and left with you.
We gain an understanding of your Organisation’s top priorities, and show you how AI & ML can introduce new revenue channels, decrease costs, and improve productivity leading to significant return on investment (ROI) and Business benefits.


Home
Specialist
Patient Care
Staff Account
About Us
Contuct Us
Medicine Entry Form
Supplier ID:
Supplier Name:
Date of Supply:
Med ID
Name
Unit price
Quantity
Manufacture date
Expiry Date
Submit form


About ZunZunSite3
This site is dedicated to Jesus of Nazareth, and was written by James R. Phillips.
The site is a natural outgrowth of my previous Research and Development days in Washington, D.C.,
my previous software engineering work in Tokyo, Japan and now in Birmingham, AL, USA.
The name of the project, ZunZunSite3, is taken from my wife's Burmese nickname.


From the Editor’s Desk
We hope this issue helps inform our university community and empowers them to use their voice in important budgetary discussions.
Budget Before and After COVID-19
The university anticipates a $35 to $38 million deficit for FY23.
Clarifying the 'Crisis'
While Ohio University’s financial state is not at a “crisis” level, faculty agree proper management remains critical.
Instruction After Layoffs
“I feel very saddened by the turn of the university and the way they've chosen to deal with this situation,” Molly Morrison, an Italian professor in the department of modern languages, said.
Budget Being Overlooked
Graham Knerr, a freshman studying civil engineering, said he considered the budget to understand how much money was being put toward his major.
Hot Takes with Tate
OU should do a better job of showing students exactly what they’re paying for.
Admin Worries
Some faculty members worry an increase in administrative costs will affect students in the form of less class offerings and larger class sizes.
Tuition Thaw
Each year, the state of Ohio decides the maximum percentage increase of tuition public universities can implement.
Student Movement Struggles
In the movements’ absence, others have yet to take their place.
Student Wages Update
Jim Sabin, a university spokesperson, said the university has had difficulties filling open positions within student employment.
Thinking in Print
My education and course options have suffered due to the loss of OU’s professors.
Want to learn more about us? Check us out at thepostathens.com, email us at<EMAIL_ADDRESS>or follow our social media below!


This is a safe site. Your personal information is protected.
Monday to Friday, 9am to 5pm
Closed public holidays


How to use this app
- Select and upload a file with .json file extension
- After successful upload, Create an index of the file by clicking Select File
- Index your file of choosing from the dropdown
- You can search for keywords in your indexed file in the search input
| Words | {{'Document '+(index+1)}} |
|---|---|
| {{key}} | X Not Found |


2021 Y-BASE-AI-Symposium
Title1: Everything You Need to Know to Reproduce Upcoming Immersive METAVERSE Media: Quality of Experience (QoE)
Time: Tuesday, October 26, Half Day -AM (0800-1100)
Description
Today, the metaverse is a shared virtual space where people are represented by digital avatars (think Ready Player One). The virtual world constantly grows and evolves based on the decisions and actions of the society within it. Eventually, people will be able to enter the metaverse, completely virtual (i.e. with virtual reality) or interact with parts of it in their physical space with the help of augmented and mixed reality. However, making fully interactive 3D metaverses with high-quality video has never been easier.
Therby, it is necessary to assess the quality of experience (QoE) perceived by users adaptive to those future multimedia systems. In this context, this tutorial aims at bridging together the current research advances with QoE assessment. Moreover, this tutorial will discuss how to evaluate the QoE for next generation multimedia from the human cognitive perspective, present the latest articles aligned with recent industrial trend, contents acquisition and quality assessment, and have technical exchanges.


Week # 1 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Jan 10 |
Jan 11 |
Jan 12 |
Jan 13 |
Jan 14 |
|
|
LESSON 1 |
No Quiz |
LESSON 2 |
No Quiz |
LESSON 3 |
|
|
13.1 Vectors in the Plane |
HW DUE: None |
13.2 Vectors in Three Dimensions (remainder) |
HW DUE: Lessons 1 & 2 |
13.3 Dot Products |
Week # 2 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Jan 17 |
Jan 18 |
Jan 19 |
Jan 20 |
Jan 21 |
|
|
No Class |
Quiz 1 |
LESSON 4 |
Quiz 2 |
LESSON 5 |
|
|
Martin Luther King Jr. Day |
HW DUE: Lesson 3 |
13.4 Cross Products |
HW DUE: Lesson 4 |
6.2 Regions Between Curves |
Week # 3 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Jan 24 |
Jan 25 |
Jan 26 |
Jan 27 |
Jan 28 |
|
|
LESSON 6 |
Quiz 3 |
LESSON 7 |
Quiz 4 |
LESSON 8 |
|
|
6.3 Volumes by Slicing |
HW DUE: Lessons 5,6 |
6.4 Volumes by Shells |
HW DUE: Lesson 7 |
6.5 Length of Curves |
Week # 4 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Jan 31 |
Feb 1 |
Feb 2 |
Feb 3 |
Feb 4 |
|
|
LESSON 9 |
Quiz 5 |
LESSON 10 |
Quiz 6 (Lessons 8,9)
|
LESSON 11 |
|
|
6.7 Physical Applications |
HW DUE: Lessons 8,9 |
6.7 Physical Applications (remainder) |
HW DUE: Lesson 10 |
8.2 Integration by Parts |
Week # 5 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Feb 7 |
Feb 8 |
Feb 9 |
Feb 10 |
Feb 11 |
|
|
Exam REVIEW |
|
LESSON 12 |
Quiz 7 |
NO CLASS |
|
|
REVIEW |
HW DUE: none |
8.3 Trigonometric Integrals |
HW DUE: Lessons 11 |
Class canceled due to exam |
Week # 6 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Feb 14 |
Feb 15 |
Feb 16 |
Feb 17 |
Feb 18 |
|
|
LESSON 13 |
Quiz 8 |
LESSON 14 |
Quiz 9 |
LESSON 15 |
|
|
8.3 Trigonometric Integrals |
HW DUE: Lessons 12,13 |
8.4 Trigonometric Substitutions |
HW DUE: Lesson 14 |
8.4 Trigonometric Substitutions |
Week # 7 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Feb 21 |
Feb 22 |
Feb 23 |
Feb 24 |
Feb 25 |
|
|
LESSON 16 |
Quiz 10 |
LESSON 17 |
Quiz 11 |
LESSON 18 |
|
|
8.5 Partial Fractions |
HW DUE: Lessons 15,16 |
8.5 Partial Fractions |
HW DUE: Lesson 17 |
8.9 Improper Integrals |
Week # 8 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Feb 28 |
Mar 1 |
Mar 2 |
Mar 3 |
Mar 4 |
|
|
LESSON 19 |
Quiz 12 |
LESSON 20 |
Quiz 13 |
LESSON 21 |
|
|
10.1 Sequences and Series: An Overview |
HW DUE: Lessons 18, 19 |
10.2 Sequences |
HW DUE: Lesson 20 |
10.3 Infinite Series |
Week #9 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Mar 7 |
Mar 8 |
Mar 9 |
Mar 10 |
Mar 11 |
|
|
Exam REVIEW |
Exam REVIEW |
LESSON 22 |
Quiz 14 |
NO CLASS |
|
|
REVIEW |
HW DUE: none EXAM #2 (Lessons 10-20) |
10.4 The Divergence and Integral Tests (up to example 3) |
HW DUE: Lessons 21
|
Class canceled due to exam |
Week # 10 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Mar 14 |
Mar 15 |
Mar 16 |
Mar 17 |
Mar 18 |
|
|
No Class |
No Class |
No Class |
No Class |
No Class |
|
|
Spring Break |
Spring Break |
Spring Break |
Spring Break |
Spring Break |
Week # 11 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Mar 21 |
Mar 22 |
Mar 23 |
Mar 24 |
Mar 25 |
|
| NO CLASS |
Quiz 15 |
LESSON 23 |
Quiz 16 |
LESSON 24 | |
| Class canceled due to exam |
HW DUE: Lesson 22 |
10.5 The Comparison Tests |
HW DUE: Lesson 23 |
10.6 Alternating Series |
Week # 12 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Mar 28 |
Mar 29 |
Mar 30 |
Mar 31 |
Apr 1 |
|
| LESSON 25 |
Quiz 17 |
LESSON 26 |
Quiz 18 |
LESSON 27 | |
| 10.7 The Ratio and Root Tests |
HW DUE: Lessons 24, 25 |
10.8 Choosing a Convergence Test |
HW DUE: Lesson 26 |
11.1 Approximating Functions with Polynomials (up to example 4) |
Week # 13 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Apr 4 |
Apr 5 |
Apr 6 |
Apr 7 |
Apr 8 |
|
| LESSON 28 |
Quiz 19 |
LESSON 29 |
Quiz 20 |
LESSON 30 | |
|
11.1 Approximating Functions with Polynomials |
HW DUE: Lesson 27,28 |
11.2 Properties of Power Series (up to example 3) |
HW DUE: Lesson 29 |
11.2 Properties of Power Series |
Week # 14 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Apr 11 |
Apr 12 |
Apr 13 |
Apr 14 |
Apr 15 |
|
|
Exam REVIEW |
Exam REVIEW |
LESSON 31 |
Quiz 21 |
LESSON 32 |
|
|
REVIEW |
HW DUE: Lesson 30 |
11.3 Taylor Series |
HW DUE: Lesson 31 |
11. 4 Working with Taylor Series |
Week #15 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Apr 18 |
Apr 19 |
Apr 20 |
Apr 21 |
Apr 22 |
|
|
LESSON 33 |
Quiz 22 |
LESSON 34 |
Quiz 23 (Lesson 32,33) |
LESSON 35 |
|
|
12.2 Polar Coordinates |
HW DUE: Lessons 32,33 |
12.2 Polar Coordinates |
HW DUE: Lesson 34 |
12.3 Areas and Lengths in Polar Coordinates |
Week # 16 |
|
||||
|
MONDAY |
TUESDAY |
WEDNESDAY |
THURSDAY |
FRIDAY |
|
|
Apr 25 |
Apr 26 |
Apr 27 |
Apr 28 |
Apr 29 |
|
|
Final Review |
No Quiz Review |
Final Review |
No Quiz Review |
Final Review |
|
|
REVIEW |
HW DUE: Lesson 35 |
REVIEW |
HW DUE: none |
REVIEW |


{% block analytics %}
{% endblock %}
Copyright © 2018 Colorlib. All rights reserved. Template by Colorlib.
{% load static %}
Copyright © 2018 Colorlib. All rights reserved. Template by Colorlib.


{% import "macros.html" as macros %}
{$ interface.name $}
{$ interface.description | marked | safe $}


{title}
{nav}{body}
#^_docs_json
{
// ignore anything containing this text
// so we can skip .git and node_modules etc
ignore:{
"node_modules":true,
},
// search in these dirs (relative to the root of source)
// to find files that end with the given value
dirs:{
"../../js":"",
},
// create url links by replacing the beginning of filenames like so
urlprefix:{
"../js/":"https://github.com/xriss/plated/blob/master/js/",
},
}
#^wrap


breadCrumbs - (2015, Phase 3 of Dev Bootcamp) - Falling halfway between Geocaching and Snapchat, breadCrumbs allows you to leave notes and photos for friends to find in specific geolocations. Each momento, or breadCrumb, is viewable by the recipient when they arrive at the designated location. breadCrumbs is an iOS app written in Swift with a backend server built with Ruby on Rails. This was my final group project at Dev Bootcamp. The front-end repo can be found here.
What's for Dinner? - (2015, Phase 2 of Dev Bootcamp) - A recipe app that allows users to create, share, and collect recipes. I was interested in making recipe input as natural as possible while still processing each individual ingredient for the database. I built this over the course of 2 days with Ruby and Sinatra. Repo located here.
Git Cheat Sheet - (2015, Phase 0 of Dev Bootcamp) - A quick, handy reference of git commands. I focused on those that I used most often.
REE Calculator - (2015, Pre-Dev Bootcamp) - My first serious attempt at making a web app with Ruby and Sinatra. Styling via Bootstrap. This app will calculate calorie needs for weight loss and weight maintenance. I built this to speed up some of the more time-consuming calculations that I needed to do as part of my job. I also got to play around with Google Analytics to monitor site traffic.
I'll continue to add projects to this list in the future.